day23+day24：java集合
集合
- java集合框架的概述
- Collection接口方法的使用
- Iterator迭代器接口
- Collection子接口之一：List接口
-
-
- list实现类之一：ArrayList
- list实现类之二：LinkedList
- list实现类之三：Vector
-
- Collection子接口之二：Set接口
-
-
- Set实现类之一：HashSet
- Set实现类之二：LinkedHashSet
- Set实现类之三：TreeSet
-
- Map接口
-
-
- Map实现类之一：HashMap
- Map实现类之二：LinkedHashMap
- Map实现类之三：TreeMap
- Map实现类之四：Hashtable
- Map实现类之五：Properties
-
- Collections工具类
-
-
- 练习
-
java集合框架的概述
一、集合框架的概述
1、集合、数组都是对多个数进行存储操作的结构，简称java容器。
说明：此时的存储，主要指的是内存层面的存储，不涉及到持久化的存储（硬盘、数据库等）
2.1、数组在存储多个数据方面的特点：
>一旦初始化以后，其长度就确定了
>数组一旦定义好，其元素的类型也就确定了。我们只能操作指定类型的数据了
比如:String[] arr ; int[] arr1 ; Object[] arr2
2.2、数组在存储多个数据方面的缺点：
>一旦初始化以后，其长度不可修改。
>数组种提供的方法非常有限，对于添加、删除、插入数据等操作，非常不便，同时效率不高。
>获取数组种实际元素的个数的需求，数组没有现成的方法可用
>数组存储数据的特点：有序、可重复。对于无序、不可重复的需求，不能满足。
二、集合框架
|---Collection接口：单列集合，用来存储一个一个的对象
|---List接口：存储有序的、可重复的数据。 --->“动态数组”
|---ArrayList、LinkedList、Vector
|---Set接口：存储无序的、不可重复的数据。 --->高中讲的“集合”
|---HashSet、LinkedHashSet、TreeSet
|---Map接口：双列集合，用来存储1一对（key-value）一对的数据 --->高中的函数 y=f(x)
|---HashMap、LinkedHashMap、TreeMap、Hashtable、Properties
Collection接口方法的使用
常用的方法如下：
import org.junit.jupiter.api.Test;
import java.util.*;
//Collection接口中常用方法的测试
//向 Collection 接口中的实现类对象添加数据obj时，要求obj所在的类重写equals()方法
public class collectionTest {
@Test
public void test1(){
Collection coll = new ArrayList();
//add(Object e):将元素 e 添加到集合coll种
coll.add("AA");
coll.add("BB");
coll.add(123);
coll.add(new Date());
//size():获取添加的元素个数，没有则输出0
System.out.println(coll.size());//4
//addAll():将集合coll1集合中的元素添加到当前的集合中
Collection coll1 = new ArrayList();
coll1.add(456);
coll1.add("CC");
coll.addAll(coll1);
System.out.println(coll.toString());//[AA, BB, 123, Tue Nov 16 10:12:58 CST 2021, 456, CC]
//clear():清空集合元素
coll.clear();
//isEmpty():判断当前集合是否为空
System.out.println(coll.isEmpty());//即判断size()是否为0
coll.add(123);
coll.add(456);
coll.add(new String("Tom"));
coll.add(false);
coll.add(new Person("Jerry",20));
Person p = new Person("Jerry",20);
coll.add(p);
//contains(Object obj):判断当前集合是否包含 obj
// 我们在判断时会调用obj所在类的 equals() 方法，自定义类都要重写 equals() 方法
System.out.println(coll.contains(123));//true
System.out.println(coll.contains(new String("Tom")));//true //判断内容
System.out.println(coll.contains("Tom"));//true
System.out.println(coll.contains(p));//true //同一个引用
System.out.println(coll.contains(new Person("Jerry", 20))); //false //Person没有重写equals()方法，比较的是地址值
//containsAll(Collection coll):判断形参 coll 中所有的元素是否都存在于当前的集合中
Collection coll2 = Arrays.asList(123,456);
System.out.println(coll.containsAll(coll2));//true
//remove(Object obj):从当前集合中移除obj元素 【调用了 obj 的 equals()】
System.out.println(coll); //[123, 456, Tom, false, Person{name='Jerry', age=20}, Person{name='Jerry', age=20}]
coll.remove(123);
System.out.println(coll); //[456, Tom, false, Person{name='Jerry', age=20}, Person{name='Jerry', age=20}]
coll.remove(1234);
System.out.println(coll); //[456, Tom, false, Person{name='Jerry', age=20}, Person{name='Jerry', age=20}]
coll.remove(new Person("Jerry", 20)); //调用 Person 类的equals()方法，没有重写equals()时，无法移除，重写后可
System.out.println(coll); //[456, Tom, false, Person{name='Jerry', age=20}]
//removeAll(Collection coll):差集：从当前集合中移除coll当中所有的元素 【调用了 obj 的 equals()】
System.out.println(coll); //[456, Tom, false, Person{name='Jerry', age=20}]
Collection coll3 = Arrays.asList(123,"Tom",456); //共有的部分是 456 和 Tom
coll.removeAll(coll3);
System.out.println(coll); //[false, Person{name='Jerry', age=20}]
coll.addAll(coll3);
//retainAll(Collection coll):交集：获取当前集合和 coll 集合的交集，并返回给当前集合
System.out.println(coll); //[false, Person{name='Jerry', age=20}, 123, Tom, 456]
Collection coll4 = Arrays.asList(123,"Tom",456); //共有的部分是 456 和 Tom
coll.retainAll(coll4); //取交集，交集部分为 123,"Tom",456
System.out.println(coll); //[123, Tom, 456]
//equals(Object obj):要想返回true，需要当前集合和形参集合元素相同，顺序相同
System.out.println(coll); //[123, Tom, 456]
Collection coll5 = new ArrayList();//ArrayList是有序的，所哟 coll 的顺序不一样就会返回false
coll5.add(123);
coll5.add(new String("Tom"));
coll5.add(456);
System.out.println(coll.equals(coll5));
//hashcode():返回当前对象的哈希值
System.out.println(coll.hashCode());//2760944
//集合--->数组：toArray()
Object[] arr = coll.toArray();
System.out.println(Arrays.toString(arr));//[123, Tom, 456]
//拓展：数组---->集合：调用 Arrays 的静态方法 asList()
List<String> list = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(list);//[AA, BB, CC]
// List arr1 = Arrays.asList(new int[]{123,456});//[[I@5ce81285] 错误写法
List arr1 = Arrays.asList(123,456);
System.out.println(arr1.size());//2
List arr2 = Arrays.asList(new Integer[]{123,456});
System.out.println(arr2.size());//2
//iterator():返回Iterator接口的实例，用于遍历集合。（后面单独介绍）
}
}
//新建一个Person类
class Person{
private String name;
private int age;
public Person() {
}
public Person(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 String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age &&
name.equals(person.name);
}
}
Iterator迭代器接口
/**
集合元素的遍历操作，使用迭代器 Iterator 接口
内部的方法搭配使用：hasNext() 和 next()
*/
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add("AA");
coll.add("BB");
coll.add(123);
coll.add(new Date());
coll.add(false);
Iterator iterator = coll.iterator();
//方式一：
// System.out.println(iterator.next());//AA
// System.out.println(iterator.next());//BB
// System.out.println(iterator.next());//123
// System.out.println(iterator.next());//Tue Nov 16 16:44:14 CST 2021
// System.out.println(iterator.next());//false
// System.out.println(iterator.next());//报异常：java.util.NoSuchElementException
//方式二：不推荐
// for (int i = 0; i < coll.size(); i++) {
// System.out.println(iterator.next());
// }
//方式三：
//hasNext():判断是否还有下一个元素
while(iterator.hasNext()){
//next():①指针下移 ②将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
}
/*
排序的几种错误写法
*/
@Test
public void test2(){
Collection coll = new ArrayList();
coll.add("AA");
coll.add("BB");
coll.add(123);
coll.add(new Date());
coll.add(false);
Iterator iterator = coll.iterator();
//错误方式一：
// while ((iterator.next() != null)){//指针下移一次
// System.out.println(iterator.next());//指针下移二次，只输出 BB、new Date 且报异常java.util.NoSuchElementException
// }
//错误方式二
//集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
while (coll.iterator().hasNext()){
System.out.println(coll.iterator().next());//死循环，不断输出第一个对象
}
}
//测试 Iterator 中的 remove() 方法
//内部定义了remove(),可以在遍历的时候，删除集合中的元素，此方法不同于集合直接调用remove()
//【注】如果还未调用next()或在上一次调用 next 方法之后已经调用了 remove 方法，再调用remove都会报IllegalStateException。
@Test
public void test3(){
Collection coll = new ArrayList();
coll.add("AA");
coll.add("BB");
coll.add(123);
coll.add(new Date());
coll.add(false);
//删除集合中的"AA"数据
Iterator iterator = coll.iterator();
while (iterator.hasNext()){
Object obj = iterator.next();
if ("AA".equals(obj)){
iterator.remove();
}
}
//集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
iterator = coll.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
/*
BB
123
Tue Nov 16 17:36:14 CST 2021
false
*/
}
//foreach循环
package CollectionTest;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
/**
jdk 5.0 新增了foreach循环，用于遍历集合、数组
*/
public class ForTest {
//遍历集合
@Test
public void test1(){
Collection coll = new ArrayList();
coll.add("AA");
coll.add("BB");
coll.add(123);
coll.add(new Date());
coll.add(false);
//for(集合(数组)中元素类型 局部变量 : 集合(数组)对象 )
//内部仍然调用了迭代器。
for (Object obj : coll) {
System.out.println(obj);
}
/*
AA
BB
123
Tue Nov 16 17:50:38 CST 2021
false
*/
}
//遍历数组
@Test
public void test2(){
int[] arr = new int[]{1,2,3,4,5,6,8};
//for(集合(数组)中元素类型 局部变量 : 集合(数组)对象 )
for (int i : arr){
System.out.println(i);
}
}
@Test
public void test3(){
String[] arr = new String[]{"AA","AA","AA"};
//方式一：普通for循环
// for (int i = 0;i
// arr[i]="BB";
// }
//方式二:增强for循环,s是重新赋值，修改数组arr中的元素，不会改变
for (String s:arr) {
s="BB";
}
for (int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
}
Collection子接口之一：List接口
源码分析：
1、list接口框架
|---Collection接口：单列集合，用来存储一个一个的对象
|---List接口：存储有序的、可重复的数据。 --->“动态数组”,替换原有数据
|---ArrayList：作为List接口的主要实现类；线程不安全，效率高；底层使用 Object[] elementData 存储
|---LinkedList：对于频繁的插入、删除操作，此类效率比ArrayList高；底层使用双向链表存储
|---Vector：作为List接口的古老实现类；线程安全，效率低；底层使用 Object[] elementData 存储
2、ArrayList的源码分析
2.1 ArrayList源码分析： jdk7 的情况下：
ArrayLst list = new ArrayList()//底层创建了长度是10的Object[]数组elementDate
list.add(123);//相当于elementData[0]=new Integer(123);
...
list.add(11)//如果此次的添加导致底层elementData数据容量不够、则扩容。
默认情况下，扩容为原来的1.5倍，同时需要将原有数组中的数据复制到新的数组中。
结论：建议开发中使用带参的构造器：ArrayList list = new ArrayList(int capacity)
2.2 jdk 8 中ArrayList的变化：
ArrayLst list = new ArrayList()//此时底层Object[] elementData初始化为{}并没有创建长度为10的数组。
list.add(122)//第一次调用add()时，底层才创建了长度为10的数组，并将数据122添加到elementData[0]上
.。。
后续的添加和扩容操作与jdk 7 无异
2.3 小结：jdk7中的ArrayList的对象的创建类似于单例模式的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例模式的懒汉式
延迟了数组的创建，节省了内存空间。
面试题：ArrayList、LinkedList、Vector三者的异同？
同：三个类都实现了List接口，存储数据的特点相同：存储有序的、可重复的数据
不同：如上
3、LinkedList的源码分析：
LinkList list = new LinkedList();//内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象
其中Node定义为：体现了LinkedList的双向链表的说法
private static class Node<E> {
E item;
Node<E> next;//指向下一个
Node<E> prev;//指向上一个
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
4、Vector的源码分析：jdk7和jdk8中，通过Vector()构造器创建对象时，底层都创建了长度为10的数组
在扩容方面，默认扩容为原来数组的2倍。
public class ListTest {
/*
List接口中的常用方法：
void add(int index, Object ele):在index位置插入ele元素
boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
Object get(int index):获取指定index位置的元素
int indexOf(Object obj):返回obj在集合中首次出现的位置
int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置
Object remove(int index):移除指定index位置的元素，并返回此元素
Object set(int index, Object ele):设置指定index位置的元素为ele
List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的子集合
总结常用方法：
增：add(Object obj) addAll()
删：remove(int index) / remove(Object obj)
改：Object set(int index, Object ele)
查：Object get(int index)
插：add(int index, Object ele)
长度：size()
遍历：① Iterator迭代器方式
② 增强for循环foreach
③ 普通循环
*/
@Test
public void test1(){
//以ArrayList为例，ArrayList时比较常用的实现类
ArrayList list = new ArrayList();
list.add(123);
list.add(546);
list.add(new Date());
list.add("AA");
System.out.println(list);//[123, 546, Thu Nov 18 17:53:51 CST 2021, AA] 输出的顺序就是添加的顺序，是有序的
//void add(int index, Object ele):在index位置插入ele元素,其后面的元素后移(若为LinkedList则是指针指向变化)
list.add(1,"BB");
System.out.println(list);//[123, BB, 546, Thu Nov 18 17:57:43 CST 2021, AA]
//boolean addAll(int index, Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList(1, 2, 3);
list.addAll(list1);
System.out.println(list.size());//8
//Object get(int index):获取指定index位置的元素
System.out.println(list);//[123, BB, 546, Thu Nov 18 22:59:47 CST 2021, AA, 1, 2, 3]
System.out.println(list.get(2));//546
//int indexOf(Object obj):返回obj在集合中首次出现的位置，若在集合中找不到obj则返回-1
System.out.println(list.indexOf("BB"));//1
System.out.println(list.indexOf(1234));//-1
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置，若在集合中找不到obj则返回-1
list.add("BB");
System.out.println(list);//[123, BB, 546, Thu Nov 18 23:03:59 CST 2021, AA, 1, 2, 3, BB]
System.out.println(list.lastIndexOf("BB"));//8
//Object remove(int index):移除指定index位置的元素，并返回此元素
System.out.println(list);//[123, BB, 546, Thu Nov 18 23:23:00 CST 2021, AA, 1, 2, 3, BB]
Object obj = list.remove(3);
System.out.println(obj);//Thu Nov 18 23:23:53 CST 2021
System.out.println(list);//[123, BB, 546, AA, 1, 2, 3, BB]
//Object set(int index, Object ele):设置指定index位置的元素为ele
System.out.println(list);//[123, BB, 546, AA, 1, 2, 3, BB]
list.set(1,"CC");
System.out.println(list);//[123, CC, 546, AA, 1, 2, 3, BB]
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置左闭右开区间的子集合,原集合不变
List list2 = list.subList(1, 4);
System.out.println(list);//[123, CC, 546, AA, 1, 2, 3, BB]
System.out.println(list2);//[CC, 546, AA]
// list.subList(1,10);//IndexOutOfBoundsException 脚标越界
}
//List的遍历
@Test
public void test2(){
ArrayList list = new ArrayList();
list.add(123);
list.add(546);
list.add("AA");
//① Iterator迭代器方式
Iterator iterator = list.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("**************************************************");
//② 增强for循环foreach
for (Object o: list) {
System.out.println(o);
}
System.out.println("*************************************************");
//③ 普通循环
for (int i = 0; i < list.size(); i++) {
list.get(i);
}
}
}
list实现类之一：ArrayList
面试题：
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;
/**
区分List当中的remove方法
remove(int index)
remove(Object obj)
*/
public class ListExer {
@Test
public void testListRemove() {
List list = new ArrayList();
list.add(1);
list.add(2);
list.add(3);
updateList(list);
System.out.println(list);//[1, 2]
}
private static void updateList(List list) {
list.remove(2);//删除的是索引为2的数据
// list.remove(new Integer(2));//删除数据2
}
}
list实现类之二：LinkedList
list实现类之三：Vector
Collection子接口之二：Set接口
1、Set接口的框架
|---Collection接口：单列集合，用来存储一个一个的对象
|---Set接口：存储无序的、不可重复的数据。 --->高中讲的“集合”
|---HashSet: 作为 Set 接口的主要实现类，线程不安全，可以存储 null 值
|---LinkedHashSet: 作为HashSet的子类：遍历其内部数据时，可以按照添加的顺序遍历。
|---TreeSet: 可以按照添加对象的指定属性进行排序。
【注】
1、Set接口中没有额外定义新的方法，使用的都是Collection中声明过的方法。
2、要求：向 Set 中添加的数据，其所在的类一定要重写 hashCode() 和 equals()方法
要求：重写的 hashCode() 和 equals()方法尽可能保持一致性 “相等的对象必须具有相等的散列码”
Set实现类之一：HashSet
public class SetTest {
/*
一、Set接口：存储无序的、不可重复的数据。
以 HashSet 为例说明
1、无序性：不等于随机性.存储的数据在底层数组中并非按照数组索引的顺序添加，而是按照哈希值决定的
2、不可重复性：保证添加的元素按照 equals() 判断时，不能返回 true，即相同的元素只能添加一个
二、添加元素的过程：以HashSet为例：
向 HashSet 中添加元素 a，首先调用元素 a 所在类的 hashCode() 方法，计算元素a的哈希值，
此哈希值接着通过某种算法计算出在 HashSet 底层数组中存放的位置（即为索引位置），
判断数组此位置上是否有元素：
如果此位置上没有其他元素，则元素a添加成功。 --->情况1
如果此位置上有其他元素b(或以链表形式存在的多个元素)，判断则比较元素a与元素b的哈希值
如果哈希值不相同，则元素a添加成功 --->情况2
如果哈希值相同，进而需要调用元素a所在类的equals()方法：
equals()返回true，元素a添加失败
equals()返回false，则元素a添加成功 --->情况3
对于添加成功的情况2和情况3而言：元素a 与已经存在指定索引位置上数据以链表的方式存储。
jdk7：元素a放到数组中，指向原来的元素
jdk8：原来的元素在数组中，指向元素a
总结:7上8下
HashSet底层：数组+链表 的结构
*/
@Test
public void test1(){
Set set = new HashSet();
set.add(123);
set.add(456);
set.add("AA");
set.add("BB");
set.add(new User("Tom",20));
set.add(new User("Tom",20));
set.add(789);
set.add(789);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
import java.util.Objects;
public class User {
private String name;
private int age;
public User() {
}
public User(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 String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()...");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
HashSet添加后的存放方式
要求：向 Set 中添加的数据，其所在的类一定要重写 hashCode() 和 equals()方法
要求：重写的 hashCode() 和 equals()方法尽可能保持一致性 “相等的对象必须具有相等的散列码”
hashSet的底层源码
public HashSet() {
map = new HashMap<>();
}
//add:向hashSet中添加数据实际上就添加到了hashMap里了
public boolean add(E e) {
return map.put(e, PRESENT)==null;
}
//hashSet的底层实现是hashMap
Set实现类之二：LinkedHashSet
//LinkedHashSet的使用
//LinkedHashSet 作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
//优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
@Test
public void test2(){
Set set = new LinkedHashSet();
set.add(123);
set.add(456);
set.add("AA");
set.add("BB");
set.add(new User("Tom",20));
set.add(new User("Tom",20));
set.add(789);
set.add(789);
System.out.println(set);//[123, 456, AA, BB, User{name='Tom', age=20}, 789] 遍历的顺序与添加顺序相同
}
相当于LinkedHashSet在原有的HashSet之上，又而外的提供了一对双向链表，来记录添加的先后顺序。对于频繁的遍历操作，LinkedHashSet效率高于HashSet
Set实现类之三：TreeSet
1、向 TreeSet 中添加的数据，要求是同一个类的对象
2、两种排序方式，自然排序(实现Comparable接口) 和定制排序（Comparator）
3、自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals().
4、在定制排序中，比较两个对象是否相同的方法的标准为：compare()返回0，不再是equals().
【注】
1、集合Collection中存储的如果是自定义类的对象，需要自定义类重写哪个方法？为什么？
List：equals()方法
Set：(HashSet、LinkedHashSet为例)：equals()、hashCode()
(TreeSet为例)：Comparable：compareTo(Object obj)
Comparator：compare(Object o1,Object o2)
2、TreeSet底层是二叉树结构。
//自然排序
@Test
public void test1(){
TreeSet set = new TreeSet();
//失败：不能向TreeSet中添加不同类的对象
// set.add(123);
// set.add(456);
// set.add("AA");
// set.add(new User("Tom",20));
//没有输出操作直接运行报异常
//ClassCastException: java.lang.Integer cannot be cast to java.lang.String
//举例一：
//都是Integer类型的数据，添加成功
// set.add(34);
// set.add(-34);
// set.add(12);
// set.add(9);
// set.add(25);
//举例二：
set.add(new User("Tom",20));
set.add(new User("Jerry",34));
set.add(new User("jim",25));
set.add(new User("Mike",15));
set.add(new User("Jack",9));
set.add(new User("Jack",45));//先排姓名，姓名相同没有二级排序则不会添加进LinkedHashSet中
//没有写排序之前，报异常：ClassCastException: SetTest.User cannot be cast to java.lang.Comparable
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
//举例一输出：-34 9 12 25 34 从小到大排列
/*
举例二输出：
User{name='Jack', age=9}
User{name='Jerry', age=34}
User{name='Mike', age=15}
User{name='Tom', age=20}
User{name='jim', age=25}
*/
}
//User中重写的CompareTo方法
//按照姓名从小到大排列
@Override
public int compareTo(Object o) {
if (o instanceof User){
User user = (User)o;
// return this.name.compareTo(user.name);
int compare = this.name.compareTo(user.name);
if (compare!=0){
return compare;
}else {
return Integer.compare(this.age,user.age);
}
}else {
throw new RuntimeException("输入类型不匹配");
}
}
//定制排序
@Test
public void test2(){
//按照年龄从小到大排列，
Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof User && o2 instanceof User){
User user1 = (User)o1;
User user2 = (User)o2;
int compare = Integer.compare(user1.getAge(), user2.getAge());
if (compare!=0){
return compare;
}else{
return user1.getName().compareTo(user2.getName());
}
}else {
throw new RuntimeException("输入类型不匹配");
}
}
};
TreeSet set = new TreeSet(com);
set.add(new User("Tom",20));
set.add(new User("Jerry",34));
set.add(new User("jim",20));
set.add(new User("Mike",15));
set.add(new User("Jack",9));
set.add(new User("Jack",45));
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
}
TreeSet自然排序与定制排序练习题：
定义一个 Employee 类。
该类包含：private 成员变量 name,age,birthday，其中 birthday 为MyDate 类的对象；
并为每一个属性定义 getter, setter 方法；
并重写 toString 方法输出 name, age, birthday
MyDate 类包含:
private 成员变量 year,month,day；并为每一个属性定义 getter, setter 方法；
创建该类的 5 个对象，并把这些对象放入 TreeSet 集合中（下一章：TreeSet 需使用泛型来定义）分别按以下两种方式对集合中的元素进行排序，并遍历输出：
1). 使 Employee 实现 Comparable 接口，并按 name 排序
2). 创建 TreeSet 时传入 Comparator 对象，按生日日期的先后排序。
//MyDate 类包含:
//private 成员变量 year,month,day；并为每一个属性定义 getter, setter 方法；
public class MyDate {
private int year;
private int month;
private int day;
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public int getDay() {
return day;
}
public void setDay(int day) {
this.day = day;
}
public MyDate() {
}
public MyDate(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
@Override
public String toString() {
return "MyDate{" +
"year=" + year +
", month=" + month +
", day=" + day +
'}';
}
}
/*
定义一个 Employee 类。
该类包含：private 成员变量 name,age,birthday，其中 birthday 为MyDate 类的对象；
并为每一个属性定义 getter, setter 方法；
并重写 toString 方法输出 name, age, birthday
*/
public class Employee implements Comparable {
private String name;
private int age;
private MyDate birthday;
public Employee(String name, int age, MyDate birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
public Employee() {
}
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 MyDate getBirthday() {
return birthday;
}
public void setBirthday(MyDate birthday) {
this.birthday = birthday;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + '\'' +
", age=" + age +
", birthday=" + birthday +
'}';
}
//使 Employee 实现 Comparable 接口，并按 name 排序
@Override
public int compareTo(Object o) {
if (o instanceof Employee){
Employee e = (Employee)o;
return this.name.compareTo(e.name);
}else {
throw new RuntimeException("输入的类型不匹配");
}
}
}
/*
创建该类的 5 个对象，并把这些对象放入 TreeSet 集合中（下一章：TreeSet 需使用泛型来定义）分别按以下两种方式对集合中的元素进行排序，并遍历输出：
1). 使 Employee 实现 Comparable 接口，并按 name 排序
2). 创建 TreeSet 时传入 Comparator 对象，按生日日期的先后排序。
*/
import org.junit.jupiter.api.Test;
import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;
/**
创建该类的 5 个对象，并把这些对象放入 TreeSet 集合中,分别按以下两种方式对集合中的元素进行排序，并遍历输出：
*/
public class EmployeeTest {
//自然排序：使 Employee 实现 Comparable 接口，并按 name 排序
@Test
public void test1(){
TreeSet set = new TreeSet();
Employee e1 = new Employee("Tom",20,new MyDate(2000,9,12));
Employee e2 = new Employee("Jerry",34,new MyDate(1986,5,15));
Employee e3 = new Employee("jim",20,new MyDate(2000,9,19));
Employee e4 = new Employee("Mike",15,new MyDate(2005,12,13));
Employee e5 = new Employee("Jack",9,new MyDate(2011,1,6));
set.add(e1);
set.add(e2);
set.add(e3);
set.add(e4);
set.add(e5);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
//定制排序：创建 TreeSet 时传入 Comparator 对象，按生日日期的先后排序。
@Test
public void test(){
Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Employee && o2 instanceof Employee){
Employee e1 = (Employee)o1;
Employee e2 = (Employee)o2;
MyDate b1 = e1.getBirthday();
MyDate b2 = e2.getBirthday();
//比较年
int minusYear = b1.getYear() - b2.getYear();
if (minusYear != 0){
return minusYear;
}
//比较月
int minusMonth = b1.getMonth() - b2.getMonth();
if (minusMonth != 0){
return minusMonth;
}
//比较日
return b1.getDay() - b2.getDay();
}
throw new RuntimeException("输入的数据类型不一致");
}
};
TreeSet set = new TreeSet(com);
Employee e1 = new Employee("Tom",20,new MyDate(2000,9,12));
Employee e2 = new Employee("Jerry",34,new MyDate(1986,5,15));
Employee e3 = new Employee("jim",20,new MyDate(2000,9,19));
Employee e4 = new Employee("Mike",15,new MyDate(2005,12,13));
Employee e5 = new Employee("Jack",9,new MyDate(2011,1,6));
set.add(e1);
set.add(e2);
set.add(e3);
set.add(e4);
set.add(e5);
Iterator iterator = set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
}
Set 两道练习
//练习：在List内去除重复数字值，要求尽量简单
public static List duplicateList(List list) {
HashSet set = new HashSet();//直接将ArrayList里的元素添加到HashSet中，添加的过程中就已经过滤了
set.addAll(list);
return new ArrayList(set);
}
@Test
public void test1() {
List list = new ArrayList();
list.add(new Integer(1));
list.add(new Integer(2));
list.add(new Integer(2));
list.add(new Integer(4));
list.add(new Integer(4));
List list2 = duplicateList(list);
for (Object integer : list2) {
System.out.println(integer);
}
}
面试题：
@Test
public void test2(){
HashSet set = new HashSet();
Person p1 = new Person(1001,"AA");
Person p2 = new Person(1002,"BB");
set.add(p1);
set.add(p2);
// System.out.println(set);//[Person{id=1002, name='BB'}, Person{id=1001, name='AA'}]
p1.name = "CC";//改变p1={id=1001,"CC"} , 但是没有改变其在哈希表中所在位置，p1还处于{id=1001,"AA"}的哈希值所在位置
set.remove(p1);//remove p1={id=1001,"CC"},在计算哈希值的时候，计算{id=1001,"CC"}的位置，并删除位置上的元素，而p1在{id=1001,"AA"}的位置上
System.out.println(set);//[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}]
set.add(new Person(1001,"CC"));//此时{id=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);//
//[Person{id=1002, name='BB'}, Person{id=1001, name='CC'}, Person{id=1001, name='CC'}, Person{id=1001, name='AA'}]
}
//新建Person类
class Person{
int id;
String name;
public Person() {
}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return id == person.id &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(id, name);
}
}
Map接口
一：Map实现类的结构：
|---Map : 双列数据，用于存储 key-value 对的数据（键值对）---类似于高中的函数 y=f(x)
|---HashMap : 作为 Map 的主要实现类；线程不安全，效率高；存储 null 的 key 和 value
|---LinkedHashMap : 保证在遍历 map 元素时，可以按照添加的顺序实现遍历
原因：在原有的 HashMap 底层结构的基础上，添加了一对指针，指向前一个和后一个元素。
对于频繁的遍历操作，此类效率高于 HashMap.
|---TreeMap : 保证按照添加的 key-value 对进行排序，实现排序遍历。
此时考虑key的自然排序或定制排序，底层属于红黑树。
|---Hashtable : 作为 Map 古老的实现类；线程安全，效率低；不能存储 null 的 key 和 value
|---properties : 常用来处理配置文件，key-value都是 String 类型
@Test
public void test1(){
Map map = new HashMap();
Map map1 = new Hashtable();
map.put(null,null);
// map1.put(null,null);//报出异常：java.lang.NullPointerException
}
HashMap 的底层：数组 + 链表（jdk7之前）
数组+链表+红黑树（jdk8）
面试题：
1、HashMap 的底层实现原理？
2、HashMap 和 Hashtable的异同？
3、CurrentHashMap 与 Hashtable 的区别？
二、Map结构的理解
Map 中的 key：无序的、不可重复的，使用 Set 存储所有的 key --->key 所在的类要重写 equals() 和 hashCode() 方法（以HashMap为例）
Map 中的 value：无序的，可重复的，使用 Collection 存储所有的 value --->所在类重写 equals()
一个键值对：key-value构成了一个 Entry 对象
Map 中的 Entry：无序的、不可重复的，使用 Set 存储所有 Entry
三、HashMap 的底层实现原理？以jdk7为例说明：
HashMap map = new HashMap();
在示例化以后，底层创建了长度是16的一维数组 Entry[] table。
。。。执行多次put后。。。
map.put(key1,value1);
首先，调用 key1 所在类的 hashCode() 计算key1哈希值，此哈希值经过某种算法计算以后，得到在 Entry 数组中的存放位置。
如果此位置上的数据为空，此时的 key1-value1 添加成功。 --->情况1
如果此位置上的数据不为空（此位置上存在一个或多个数据（以链表的形式存在）），比较 key1 和已经存在的一个或多个数据的哈希值
如果 key1 的哈希值与已经存在的数据的哈希值都不相同，此时 key1-value1 添加成功。 --->情况2
如果 key1 的哈希值和已经存在的某一个数据的哈希值相同，继续比较：调用 key1 所在类的 equals()方法比较：
如果 equals() 返回 false : 此时 key1-value1 添加成功 --->情况3
如果 equals() 返回 true :将 value1替换相同 key 的 value 值，此时的 put()方法是修改作用而非替换
补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储
在不断地添加过程中，会涉及到扩容问题，当超出临界值时（且要存放的位置非空时），默认扩容方式：扩容为原来的2倍，并将原来的数据复制过来。
jdk8 相较于 jdk7 在底层实现方面的不同：
1、new HashMap():底层没有创建一个长度为16的数组
2、jdk8 底层的数组是 Node[] 数组 而非 Entry[] 数组
3、首次调用 put() 方法时，底层创建长度为16的数组
4、jdk7 底层只有 数组 + 链表 ，jdk8 中底层结构：数组 + 链表 + 红黑树
当数组某一个索引位置上的 元素以量表形式存在个数 > 8 且当前数组长度 > 64 时，
此时此索引位置上的数据改为使用红黑树存储。
扩容的加载因子要考虑好，使得链表的结构减少些，如果加载因子过小，数组的利用率低，如果加载因子过大，链表的结构就变多
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
DEFAULT_LOAD_FACTOR：HashMap的默认加载因子：0.75
threshold：扩容的临界值，=容量*填充因子 ：16*0.75=12
TREEIFY_THRESHOLD：Bucket中链表长度大于该默认值，转化为红黑树：8
MIN_TREEIFY_CAPACITY：桶中的Node被树化时最小的hash表容量：64
/*
Map接口中定义的方法
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
总结：常用方法：
添加：put(Object key,Object value)
删除：remove(Object key)
修改：put(Object key,Object value)
查询：get(Object key)
长度：size()
遍历：keySet() / values() / entrySet()
*/
@Test
public void test3(){
/*
添加、删除、修改操作：
Object put(Object key,Object value)：将指定key-value添加到(或修改)当前map对象中
void putAll(Map m):将m中的所有key-value对存放到当前map中
Object remove(Object key)：移除指定key的key-value对，并返回value
void clear()：清空当前map中的所有数据
*/
//put()
HashMap map = new HashMap();
map.put("AA",123);
map.put(456,123);
map.put("BB",123);
map.put("AA",789);
System.out.println(map);//{AA=789, BB=123, 456=123}
// key 的 AA 只能有一个，后面使用 put 添加的 key 为 AA，相当于对 AA 的 value 值进行修改，value值是可以相同的
//putAll()
HashMap map1= new HashMap();
map1.put("CC",123);
map1.put("DD",123);
map.putAll(map1);
System.out.println(map);//{AA=789, BB=123, CC=123, DD=123, 456=123}
//remove(Object key)
Object value = map.remove("CC");
System.out.println(map);//{AA=789, BB=123, DD=123, 456=123}
System.out.println(value);//123
System.out.println(map.remove(4567));//null HashMap中没有，返回null
//clear()
map.clear();//与map=null不同
System.out.println(map.size());//0
System.out.println(map);//{}
}
/*
元素查询的操作：
Object get(Object key)：获取指定key对应的value
boolean containsKey(Object key)：是否包含指定的key
boolean containsValue(Object value)：是否包含指定的value
int size()：返回map中key-value对的个数
boolean isEmpty()：判断当前map是否为空
boolean equals(Object obj)：判断当前map和参数对象obj是否相等
*/
@Test
public void test4(){
HashMap map = new HashMap();
map.put("AA",789);
map.put("BB",0);
map.put("CC",123);
map.put("DD",456);
//get()
System.out.println(map.get("AA"));//789 找到"AA"对应的value
System.out.println(map.get("FF"));//null 若key不存在，则返回null
//containsKey() 是否包含指定的key
boolean bb = map.containsKey("BB");
System.out.println(bb);//true
//containsValue() 是否包含指定的value
boolean isExist = map.containsValue(123);//true 若有两个相同的value，则找到一个就不继续找了
//size():获取键值对数
System.out.println(map.size());//4
//boolean isEmpty()
boolean empty = map.isEmpty();
System.out.println(empty);//false
map.clear();
empty = map.isEmpty();
System.out.println(empty);//true
//equals(Object obj)
HashMap map1 = new HashMap();
System.out.println(map.equals(map1));//true
}
/*
元视图操作的方法：
Set keySet()：返回所有key构成的Set集合
Collection values()：返回所有value构成的Collection集合
Set entrySet()：返回所有key-value对构成的Set集合
*/
@Test
public void test5(){
HashMap map = new HashMap();
map.put("AA",789);
map.put("BB",0);
map.put("CC",123);
map.put("DD",456);
//遍历所有的key集：keySet()
Set set = map.keySet();//所有的key构成的集合
Iterator iterator = set.iterator();
while (iterator.hasNext()){
System.out.println(iterator.next());
}
System.out.println("******************************************************");
//遍历所有的集合：values()
Collection values = map.values();//所有values构成的集合
for (Object obj:values) {
System.out.println(obj);
}
System.out.println("**********************************************************");
//遍历所有的key-value :entrySet()
//方式一：
Set entrySet = map.entrySet();//获取所有的entry构成的set集合
Iterator iterator1 = entrySet.iterator();
while (iterator1.hasNext()){
Object obj = iterator1.next();
//entrySet 集合中的元素都是 entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey()+"--->"+entry.getValue());
}
//方式二：
Set keySet = map.keySet();//所有的key构成的集合
Iterator iterator2 = set.iterator();
while (iterator2.hasNext()){
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key + "===" + value);
}
}
Map实现类之一：HashMap
Map实现类之二：LinkedHashMap
四、LinkedHashMap的底层实现原理（了解）
源码中：
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);
}
}
@Test
public void test2(){
Map map1 = new HashMap();
map1.put(123,"AA");
map1.put(456,"BB");
map1.put(789,"CC");
System.out.println(map1);//{789=CC, 456=BB, 123=AA} 不是按照添加顺序输出
Map map2 = new LinkedHashMap();
map2.put(123,"AA");
map2.put(456,"BB");
map2.put(789,"CC");
System.out.println(map2);//{123=AA, 456=BB, 789=CC} 按照添加顺序输出
}
Map实现类之三：TreeMap
import org.junit.jupiter.api.Test;
import java.util.*;
public class TreeMapTest {
//向TreeMap中添加key-value，要求key必须是由同一个类创建的对象
//因为要按照key进行排序：自然排序 、 定制排序
//自然按照姓名，从小到大排序（详见User的CompareTo方法）
@Test
public void test(){
TreeMap map = new TreeMap();
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1,98);
map.put(u2,60);
map.put(u3,70);
map.put(u4,85);
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey()+"-->"+entry.getValue());
}
}
//定制排序
@Test
public void test2(){
Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof User && o2 instanceof User){
User u1 = (User)o1;
User u2 = (User)o2;
// return u2.getName().compareTo(u1.getName());//按照姓名从大到小
return Integer.compare(u1.getAge(),u2.getAge());//按照年龄从小到大
}else{
throw new RuntimeException("输入类型不一致");
}
}
@Override
public boolean equals(Object obj) {
return false;
}
};
TreeMap map = new TreeMap(com);
User u1 = new User("Tom",23);
User u2 = new User("Jerry",32);
User u3 = new User("Jack",20);
User u4 = new User("Rose",18);
map.put(u1,98);
map.put(u2,60);
map.put(u3,70);
map.put(u4,85);
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();
while(iterator.hasNext()){
Object obj = iterator.next();
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey()+"-->"+entry.getValue());
}
}
}
class User implements Comparable{
private String name;
private int age;
public User() {
}
public User(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 String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
System.out.println("User equals()...");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return age == user.age &&
Objects.equals(name, user.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//按照姓名从小到大排列
@Override
public int compareTo(Object o) {
if (o instanceof User){
User user = (User)o;
// return this.name.compareTo(user.name);
int compare = this.name.compareTo(user.name);
if (compare!=0){
return compare;
}else {
return Integer.compare(this.age,user.age);
}
}else {
throw new RuntimeException("输入类型不匹配");
}
}
}
Map实现类之四：Hashtable
Map实现类之五：Properties
新建文件，其后缀名为 .properties
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
public class PropertiesTest {
//Properties: 常用来处理配置文件，key 和 value 都是 String 类型的
public static void main(String[] args) {
FileInputStream fis = null;
try {
Properties pros = new Properties();
fis = new FileInputStream("jdbc.properties");
pros.load(fis);//加载流对应的文件
String name = pros.getProperty("name");//Tom
String password = pros.getProperty("password");//若输入错误，输出为null
System.out.println("name = "+name + ",password = " + password);
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Collections工具类
import org.junit.jupiter.api.Test;
import java.util.*;
/**
Collections : 操作Collection、Map的工具类
面试题 ：Collection 和 Collections 的区别？
*/
public class CollectionTest {
/*
排序操作：（均为static方法）
reverse(List)：反转 List 中元素的顺序
shuffle(List)：对 List 集合元素进行随机排序
sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
*/
/*
查找、替换
Object max(Collection)：根据元素的自然顺序，返回给定集合中的最大元素
Object max(Collection，Comparator)：根据 Comparator 指定的顺序，返回给定集合中的最大元素
Object min(Collection)
Object min(Collection，Comparator)
int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
void copy(List dest,List src)：将 src 中的内容复制到 dest 中
boolean replaceAll(List list，Object oldVal，Object newVal)：使用新值替换List 对象的所有旧值
*/
@Test
public void test(){
List list = new ArrayList();
list.add(123);
list.add(456);
list.add(789);
list.add(0);
System.out.println(list);//[123, 456, 789, 0]
//reverse(List)：反转 List 中元素的顺序
Collections.reverse(list);
System.out.println(list);//[0, 789, 456, 123]
//shuffle(List)：对 List 集合元素进行随机排序
Collections.shuffle(list);
System.out.println(list);//[789, 0, 456, 123] 随机排列，每次输出的顺序都不一样
//sort(List)：根据元素的自然顺序对指定 List 集合元素按升序排序
//sort(List，Comparator)：根据指定的 Comparator 产生的顺序对 List 集合元素进行排序
Collections.sort(list);
System.out.println(list);//[0, 123, 456, 789] //调用的是Integer里面的 CompareTo 方法
//swap(List，int， int)：将指定 list 集合中的 i 处元素和 j 处元素进行交换
Collections.swap(list,1,2);
System.out.println(list);//[0, 456, 123, 789] 交换下标为1和下标为2的元素
//int frequency(Collection，Object)：返回指定集合中指定元素的出现次数
list.add(0);
list.add(0);
list.add(0);
System.out.println(list);//[0, 456, 123, 789, 0, 0, 0]
System.out.println(Collections.frequency(list, 0));//4
//void copy(List dest,List src)：将 src 中的内容复制到 dest 中
System.out.println(list);//[0, 456, 123, 789, 0, 0, 0]
//报异常
// List dest = new ArrayList();
// Collections.copy(dest,list);
// System.out.println(dest); //java.lang.IndexOutOfBoundsException: Source does not fit in dest
//正确的
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());//7 与 list 相同
Collections.copy(dest,list);
System.out.println(dest);//[0, 456, 123, 789, 0, 0, 0]
/*
Collections 类中提供了多个 synchronizedXxx() 方法，该方法可使将指定集合包装成线程同步的集合，
从而可以解决多线程并发访问集合时的线程安全问题
*/
//返回的 list1 即为线程安全的
List list1 = Collections.synchronizedList(list);
}
}
练习
1.请从键盘随机输入10个整数保存到List中，并按倒序、从大到小的顺序显示出来
import java.util.*;
public class CollTest {
//1.请从键盘随机输入10个整数保存到List中，并按倒序、从大到小的顺序显示出来
public static void main(String[] args) {
List list = new ArrayList();
// int[] arr = new int[10];
Scanner sc = new Scanner(System.in);
for (int i=0;i<10;i++){
list.add(sc.nextInt());
}
// List list = Arrays.asList(arr);
//正序输出
System.out.println(list);//[12, 13, 5, 45, 78, 6, 5, 2, 12, 7]
Collections.reverse(list);
//逆序输出
System.out.println(list);//[7, 12, 2, 5, 6, 78, 45, 5, 13, 12]
Comparator com = new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Integer && o2 instanceof Integer){
Integer n1 = (Integer)o1;
Integer n2 = (Integer)o2;
return Integer.compare(n2,n1);
}else{
throw new RuntimeException("数据类型不一致");
}
}
};
//从大到小输出
Collections.sort(list,com);
System.out.println(list);//[78, 45, 13, 12, 12, 7, 6, 5, 5, 2]
}
}
2.请把学生名与考试分数录入到集合中，并按分数显示前三名成绩学员的名字。
TreeSet(Student(name,score,id))
/*
* 请把学生名与考试分数录入到Set中，并按分数显示前三名成绩学员的名字.怎么用Set实现?
*/
import java.util.TreeSet;
import java.util.Scanner;
import org.junit.Test;
public class ScoreTest {
private Scanner scanner;
@Test
public void test1() {
scanner = new Scanner(System.in);
TreeSet<Student> treeSet = new TreeSet<>();
System.out.println("请输入学生的姓名和成绩，当输入为负数时结束输入");
for (int i = 1;; i++) {
int score = 0;
System.out.println("请输入第" + i + "位学生的姓名：");
String name = scanner.next();
System.out.println("请输入第" + i + "位学生的成绩：(输入负数，结束录入)");
try {
score = scanner.nextInt();
} catch (ClassCastException e) {
// TODO: handle exception
System.out.println("您输入的分数有误");
}
if (score < 0) {
break;
} else {
treeSet.add(new Student(name, score));
}
}
System.out.println("您输入的成绩生成成绩单结果：");
for (Student student : treeSet) {
System.out.println(student.getName() + "--->" + student.getScore());
}
// 前三名学生的姓名
System.out.println("前三名学生的姓名为：");
int count = 0;
for (Student student : treeSet) {
if (count == 3) {
break;
} else {
System.out.println(student.getName() + "--->"
+ student.getScore());
count++;
}
}
}
}
class Student implements Comparable<Student> {
private String name;
private int score;
public Student(String name, int score) {
super();
this.name = name;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
result = prime * result + score;
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (score != other.score)
return false;
return true;
}
@Override
public int compareTo(Student o) {
// TODO Auto-generated method stub
int num = o.score - score;
if (num != 0) {
return num;
} else {
return this.name.compareTo(o.name);
}
}
}
4.对一个Java源文件中的关键字进行计数。
提示：Java源文件中的每一个单词，需要确定该单词是否是一个关键字。为
了高效处理这个问题，将所有的关键字保存在一个HashSet中。用contains()
来测试。
File file = new File("Test.java");
Scanner scanner = new Scanner(file);
while(scanner.hasNext()){
String word = scanner.next();
System.out.println(word);
}