概述
- 一方面，面向对象语言对事物的体现都是以对象的形式，为了方便对多个对象的操作，就要对对象进行存储。另一方面，使用Array存储对象方面具有一些弊端，而Java集合就像一种容器，可以动态地把多个对象的引用放入容器中。
- 数组在内存存储方面的特点:
- 数组初始化以后，长度就确定了。
- 数组声明的类型，就决定了进行元素初始化时的类型
- 数组在存储数据方面的弊端:
- 数组初始化以后，长度就不可变了，不便于扩展
- 数组中提供的属性和方法少，不便于进行添加、删除、插入等操作，且效率不高。同时无法直接获取存储元素的个数
- 数组存储的数据是有序的、可以重复的。----> 存储数据的特点单一
- Java集合类可以用于存储数量不等的多个对象，还可用于保存具有映射关系的关联数组。
Java集合可分为Collection和 Map 两种体系
- Collection接口:单列数据，定义了存取一组对象的方法的集合
- Map接口:双列数据，保存具有映射关系“key-value对”的集合 —> 高中“函数” y = f(x)
- HashMap
- LinkedHashMap
- TreeMap
- Hashtable
- Properties
Collection接口方法
- 添加
- add(Object obj)
- addAll(Collection coll)
- 获取有效元素的个数
- int size()
- 清空集合
- void clear()
- 是否是空集合
- boolean isEmpty()
- 是否包含某个元素
- boolean contains(Object obj):是通过元素的equals方法来判断是否是同一个对象
- boolean containsAll(Collection c):也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
- 删除
- boolean remove(Object obj):通过元素的equals方法判断是否是要删除的那个元素。只会删除找到的第一个元素
- boolean removeAll(Collection coll):取当前集合的差集
- 取两个集合的交集
- boolean retainAll(Collection c):把交集的结果存在当前集合中，不影响c
- 集合是否相等
- boolean equals(Object obj)
- 转成对象数组
- Object[ ] toArray()
- 获取集合对象的哈希值
- hashCode()
- 遍历
- iterator():返回迭代器对象，用于集合遍历
使用lterator接口遍历集合元素
- lterator对象称为迭代器(设计模式的一种)，主要用于遍历Collection集合中的元素。
- GOF给迭代器模式的定义为:提供一种方法访问一个容器(container)对象中各个元素，而又不需暴露该对象的内部细节。姓代器模式，就是为容器而生。类似于“公交车上的售票员”、“火车上的乘务员”、“空姐”。
- Collection接口继承了java.lang.lterable接口，该接口有一个iterator()方法，那么所有实现了Collection接口的集合类都有一个iterator()方法，用以返回一个实现了lterator接口的对象。
- lterator仅用于遍历集合，lterator木身并不提供承装对象的能力。如果需要创建lterator 对象，则必须有一个被迭代的集合。
- 集合对象每次调用iterator()方法都得到一个全新的迭代器对象，默认游标都在集合的第一个元素之前。
注意:
- lterator可以删除集合的元素，但是是遍历过程中通过迭代器对象的remove方法，不是集合对象的remove方法。
- 如果还未调用next()或在上一次调用next方法之后已经调用了remove方法，再调用remove都会报IllegalStateException。
使用foreach循环遍历集合元素(JDK5.0)
- Java 5.0提供了foreach循环迭代访问Collection和数组。
- 遍历操作不需获取collection或数组的长度，无需使用索引访问元素。
- 遍历集合的底层调用Iterator完成操作。
- foreach还可以用来遍历数组。
面试题：ArrayList、LinkedList、Vector三者异同
同：三个类都是实现了LIst接口，存储数据的特点相同：存储有序的、可重复的数据
不同：
- ArrayList:作为List接口的主要实现类；线程不安全，效率高；底层使用Object[ ] elementData存储
- LinkedList:对于频繁的插入、删除操作，使用此类效率比ArrayList高；底层使用双向链表存储
- Vector:作为List接口的古老实现类；线程是安全的，效率低；底层使用Object[ ] elementData存储
ArrayList的源码分析:
jdk7情况下
ArrayList list = new ArrayList(); 底层创建了长度是10的object[ ]数组eLementData
list.add(123); elementData[e] = new Integer(123); ... list.add(11); 如果此次的添加导致底层elementData数组容量不够，则扩容。 默认情况下，扩容为原来的容量的1.5倍，同时需要将原有数组中的数据复制到新的数组中。 结论:建议开发中使用带参的构造器: ArrayList list = new ArrayList(int capacity)
jdk8中ArrayList的变化：
ArrayList list = new ArrayList(); 底层Object[ ] elementData初始化为{ }，并没有创建长度为10的数组
list.add(123); 第一次调用add()时，底层才创建了长度为10的数组，并将数据123添加到elementData[0]中
…
后续添加和扩容操作与jdk7无异。
小结：jdk7中的ArrayList的对象的创建类似于单例的饿汉式，而jdk8中的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。
LinkedList的源码分析：
LinkedList 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;
}
}
Vector的源码分析：jdk7和jdk8中通过Vector()构造器创建对象时，底层都创建了长度为10的数组。在扩容方面，默认扩容为原来数组的2倍。
代码实现：
import org.junit.Test;
import java.util.*;
public class CollectionTest {
@Test
public void test() {
Collection collection = new ArrayList();
//add(Object o):将元素e添加到集合collection中
collection.add("AA");
collection.add("BB");collection.add(123); //自动装箱
collection.add(new Date());
//size():获取添加元素的个数
System.out.println(collection.size());//4
//addAll():将collection1集合中的元素添加到当前集合中
Collection collection1 = new ArrayList();
collection1.add("CC");
collection1.add(456789);
collection.addAll(collection1);
System.out.println(collection.size());//6
System.out.println(collection);
//clear():清空集合元素
collection.clear();
//isEmpty():判断当前集合是否为空
System.out.println(collection.isEmpty());
collection.add(new String("WLM"));
collection.add(new Person("WLM",20));
//contains(Object o):判断当前集合中是否包含obj
//我们在判断时会调用obj对象所在类的equals()方法。
//向Collection接口的实现类的对象中添加数据obj时，要求obj所在类要重写equals().
boolean contains = collection.contains("CC");
System.out.println(contains);
System.out.println(collection.contains(new String("WLM"))); //比较的是内容
System.out.println(collection.contains(new Person("WLM",20)));
//containsAll(Collection collection1):判断collection1中的所有元素是否都存在于当前集合中。
Collection collection2 = Arrays.asList(new Person("WLM",20),new String("WLM"));
boolean b = collection.containsAll(collection2);
System.out.println(b);
}
@Test
public void test1() {
Collection collection = new ArrayList();
collection.add("AA");
collection.add("BB");
collection.add(123);
collection.add(new Date());
collection.add(new String("WLM"));
collection.add(new Person("WLM",20));
//remove(Object obj)
System.out.println(collection.remove(123));
//removeAll(Collection collection1):从当前集合中移除collection1中所有元素
Collection collection1 = Arrays.asList(123,"AA","CXY","11223");
collection.removeAll(collection1);
System.out.println(collection);
//retainAll(Collection collection1):
collection.retainAll(collection1);
System.out.println(collection);
//equals(Object obj):判断当前集合和形参集合元素是否完全相等
Collection collection2 = new ArrayList();
collection2.addAll(collection);
System.out.println(collection2.equals(collection));
}
@Test
public void test2() {
Collection collection = new ArrayList();
collection.add("AA");
collection.add("BB");
collection.add(123);
collection.add(new Date());
collection.add(new String("WLM"));
collection.add(new Person("WLM",20));
//hashCode
System.out.println(collection.hashCode());
//集合 ---> 数组:toArray()
Object array[] = collection.toArray();
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
//拓展：数组 ---> 集合:调用Arrays类静态方法asList()
List<String> strings = Arrays.asList(new String[]{"AA", "BB", "CC"});
System.out.println(strings);
//数组类型转换方式一：
List array1 = Arrays.asList(123,456);
System.out.println(array1);
//数组类型转换方式二：
List array2 = Arrays.asList(new Integer[]{1,2,3,4});
System.out.println(array2);
System.out.println("******************");
}
//iterator():返回Iterator接口的实例，用于遍历集合元素。放在IteratorTest.java中测试
@Test
public void test3(){
Collection collection = new ArrayList();
collection.add("AA");
collection.add("BB");
collection.add(123);
collection.add(new Date());
collection.add(new String("WLM"));
collection.add(new Person("WLM",20));
Iterator iterator = collection.iterator();
//方式一：
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
System.out.println(iterator.next());
//超出报异常
System.out.println(iterator.next());
//方式二：不推荐
for (int i = 0; i < collection.size(); i++) {
//next():① 指针下移 ② 将下移以后集合位置上的元素返回
System.out.println(iterator.next());
}
//方式三：推荐
//hashNext():判断是否还有下一个元素。
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
@Test
public void test4() {
Collection collection = new ArrayList();
collection.add("AA");
collection.add("BB");
collection.add(123);
collection.add(new Date());
collection.add(new String("WLM"));
collection.add(new Person("WLM",20));
//删除集合中"WLM"数据
Iterator iterator = collection.iterator();
while(iterator.hasNext()){
Object object = iterator.next();
if(object.equals("WLM")){
iterator.remove();
}
}
iterator = collection.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void test5() {
Collection collection = new ArrayList();
collection.add("AA");
collection.add("BB");
collection.add(123);
collection.add(new Date());
collection.add(new String("WLM"));
collection.add(new Person("WLM",20));
//for(集合元素的类型 局部变量 ：集合对象)
for(Object obj : collection){
System.out.println(obj);
}
Object array[] = collection.toArray();
//for(数组元素的类型 局部变量 ：数组对象)
for(Object obj : array){
System.out.println(obj);
}
}
}
class Person{
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
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) {
System.out.println("Person equals()......");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
List接口
List接口方法
- List除了从Collection集合继承的方法外，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 tolndex):返回从fromIndex到toIndex位置的左闭右开区间子集合
代码实现：
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
public class ListTest {
@Test
public void test() {
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add("WLM");
list.add(new Person("WLM",18));
// void add(int index,object ele):在index位置插入eLe元素
list.add(3,"LIKE");
System.out.println(list);
//boolean addAll(int index,Collection eles):从index位置开始将eles中的所有元素添加进来
List list1 = Arrays.asList("C","X","Y");
list.addAll(list1);
System.out.println(list);
System.out.println(list.size());//9
}
@Test
public void test1() {
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add("WLM");
list.add(new Person("WLM",18));
//int indexOf(Object obj):返回obj在集合中首次出现的位置。如果不存在，返回-1
int index = list.indexOf("WLM");
System.out.println(index);
//int lastIndexOf(Object obj):返回obj在当前集合中末次出现的位置。如果不存在，返回-1
System.out.println(list.lastIndexOf("LIKE"));
//Object remove(int index):移除指定index位亶的元素，并返回此元素
Object remove = list.remove(0);
System.out.println(list);
System.out.println(remove);
//Object set(int index，object ele):设置指定index位置的元素为eLe
list.set(1,"LIKE");
System.out.println(list);
//List subList(int fromIndex, int toIndex):返回从fromIndex到toIndex位置的左闭右开区间子集合
List list1 = list.subList(1, 4);
System.out.println(list1);
}
@Test
public void test2() {
ArrayList list = new ArrayList();
list.add(123);
list.add(456);
list.add("AA");
list.add("WLM");
list.add(new Person("WLM",18));
//方式一：
Iterator iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("*****************");
//方式二：
for(Object o : list) {
System.out.println(o);
}
System.out.println("*****************");
//方式三：
for(int i=0; i<list.size(); i++) {
System.out.println(list.get(i));
}
}
}
Set接口
存储无序、不可重复的数据
以Hashset为例说明
- 无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定
- 不可重复性：保证添加的元素按照equals()判断时，不饿能返回true.即：相同元素只能添加一个。
- 向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在HashSet底层数组中的存放位置(即为：索引位置)，判断此位置上是否以及有元素。如果此位置上没有元素，则元素a添加成功。如果此位置上有其他元素b(或以链表形式存在多个元素)，则比较元素a与元素b的hash值：如果hash值不相同，则元素a添加成功。如果hash值相同，进而调用元素a的equals()方法；equals()返回true，元素a添加失败。否则，元素a添加成功。
TreeSet是 SortedSet接口的实现类，TreeSet可以确保集合元素处于排序状态。
TreeSet底层(数组+链表)使用红黑树结构存储数据
- 新增的方法如下:(了解)
- Comparator comparator()
- Object first()
- Object last()
- Object lower(Object e)
- Object higher(Object e)
- SortedSet subSet(fromElement, toElement)
- SortedSet headSet(toElement)
- SortedSet tailSet(fromElement)
- TreeSet两种排序方法:自然排序和定制排序。默认情况下，TreeSet采用自然排序。
实现类之一：HashSet
HashSet是Set接口的典型实现，大多数时候使用Set集合时都使用这个实现类。
HashSet按Hash 算法来存储集合中的元素，因此具有很好的存取、查找、删除性能。
HashSet具有以下特点:
- 不能保证元素的排列顺序
- HashSet不是线程安全的
- 集合元素可以是null
HashSet集合判断两个元素相等的标准:两个对象通过 hashCode()方法比较相等，并且两个对象的equals()方法返回值也相等。
对于存放在Set容器中的对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则。即:“相等的对象必须具有相等的散列码”。
import org.junit.Test;
import java.util.*;
public class SetTest {
@Test
public void test() {
Set set = new HashSet();
set.add(123);
set.add(456);
set.add(new String("WLM"));
set.add(new String("LIKE"));
set.add("WLM");
set.add(new People("WLM",19));
set.add(new People("WLM",20));
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
//LinkedHashSet的使用
//LinkedHashSet作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
//优点：对于频繁的遍历操作，LinkedHashSet效率高于HashSet
@Test
public void test1() {
Set set = new LinkedHashSet();
set.add(123);
set.add(456);
set.add(new String("WLM"));
set.add(new String("LIKE"));
set.add("WLM");
set.add(new People("WLM",19));
set.add(new People("WLM",20));
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
//1.向TreeSet中添加的数据，要求是像同类的对象。
//两种排序方式:自然排序 和 定制排序
//自然排序中，比较两个对象是否相同的标准为: compareTo( )返回0.不再是equals().
//定制排序中，比较两个对象是否相同的标准为: compare()返回0.不再是equals().
@Test
public void test2() {
//失败：不能添加不同类对象
// TreeSet set = new TreeSet();
// set.add(123);
// set.add(456);
// set.add(new String("WLM"));
// set.add(new String("LIKE"));
// set.add("WLM");
// set.add(new People("WLM",19));
// set.add(new People("WLM",20));
//举例一：
// TreeSet set = new TreeSet();
// set.add(new String("WLM"));
// set.add(new String("LIKE"));
// set.add("CXY");
// set.add("YJJ");
//举例二：
TreeSet set = new TreeSet();
set.add(new People("WLM",19));
set.add(new People("WLM",18));
set.add(new People("ZJN",18));
set.add(new People("YJJ",20));
set.add(new People("WRT",22));
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
@Test
public void test3() {
Comparator comparator = new Comparator() {
//按照年龄从小到大排序
@Override
public int compare(Object o1, Object o2) {
//Java17新特性
// if (o1 instanceof People p1 && o2 instanceof People p2) {
// return p1.getAge() - p2.getAge();
// } else {
// throw new UnsupportedOperationException("输入的数据类型不匹配");
// }
if(o1 instanceof People&&o2 instanceof People){
People p1 = (People)o1;
People p2 = (People)o2;
return Integer.compare(p1.getAge(),p2.getAge());
}else{
throw new RuntimeException("输入的数据类型不匹配！");
}
}
};
TreeSet set = new TreeSet(comparator);
set.add(new People("WLM",19));
set.add(new People("WLM",18));
set.add(new People("ZJN",18));
set.add(new People("YJJ",20));
set.add(new People("WRT",22));
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
class People implements Comparable{
private String name;
private int age;
@Override
public String toString() {
return "People{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
People people = (People) o;
if (age != people.age) return false;
return Objects.equals(name, people.name);
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
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 People() {
}
public People(String name, int age) {
this.name = name;
this.age = age;
}
//按名字从小到大排列,年龄从小到大排列
@Override
public int compareTo(Object o) {
if(o instanceof People){
People people = (People) o;
int result = this.name.compareTo(people.name);
if(result != 0){
return result;
}else{
return Integer.compare(this.age, people.age);
}
}else{
throw new RuntimeException("输入的类型不匹配！");
}
}
}
Map接口：
一、Map实现类的结构
Map接口:双列数据，保存具有映射关系“key-value对”的集合 —> 高中“函数” y = f{x}
- HashMap：作为Map的主要实现类；线程不安全，效率高；存储null的key和value
- LinkedHashMap：保证在遍历map元素时，可以按照添加的顺序实现遍历。 原因：在原有的HashMap底层结构基础上，添加了一对指针，指向前一个和后一个元素。对于频繁的遍历操作，此类执行效率高于HashMap。
- TreeMap：保证添加的key-value对进行排序，实现排序遍历。此时考虑key的自然排序或定制排序，底层实现为红黑树。
- Hashtable：作为古老的实现类；线程安全，效率低；
- Properties：常用来处理配置文件。key和value都是String类型。
HashMap的底层：数组+链表(jdk7及之前)
数组+链表+红黑树(jdk8)
二、Map结构的理解
Map中的key：无序的、不可重复的，使用Set存储所有的key —>key所在的类要重写equals()和hashCode()
Map中的value：无序的、可重复的，使用Collection存储所有的value —>value所在类需要重写equals()
一个键值对：key-value构成了一个Entry对象
Map中的entry：无序的、不可重复的，使用Set存储所有的entry
三、HashMap的底层实现原理
以jdk7为例说明：
在实例化以后，底层创建了长度是16的一维数组Entry[ ] table.
…可能已经执行过多次put…
map.put(key1,value1):
首先，调用key1所在类的hashCode()计算key1哈希值，此哈希值经过某种算法计算以后，得到在Entry数组中的存放位置。
如果此位置上的数据为空，此时的key1-value1添加成功。 - - -情况1
如果此位置上的数据不为空，(意味着此位置上存在一个或多个数据(以链表形式存在)),比较key1和已经存在的一个或多个数据的哈希值: 如果key1的哈希值与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。- - -情况2 如果key1的哈希值和已经存在的某一个数据(key2-vaLue2)的哈希值相同，继续比较:调用key1所在类的equals(key2) 如果equals()返回false:此时key1-value1添加成功。- - -情况3 如果equals()返回true:使用value1替换value2。
**补充：**关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储。在不断的添加过程中，会涉及到扩容问题，当超出临界值(默认的存储方式)时，扩容为原来的2倍，并将原来的数据复制过来。
jdk8相较于jdk7在底层实现方面的不同:
- new HashMap():底层没有创建一个长度为16的数组
- jdk 8底层的数组是:Node[ ],而非Entry[ ]
- 首次调用put()方法时，底层创建长度为16的数组
- jdk7底层结构只有:数组+链表。jdk8中底层结构:数组+链表+红黑树。 当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8且当前数组的长度 > 64时，此时此索引位置上的所有数据改为使用红黑树仔储。
HashMap源码中的重要常量：
DEFAULT_INITIAL_CAPACITY : HashMap的默认容量，16
HashMap的最大支持容量，2^30
DEFAULT_LOAD_FACTOR: HashMap的默认加载因子
TREEIFY_THRESHOLD: Bucket中链表长度大于该默认值，转化为红黑树
UNTREEIFY_THRESHOLD: Bucket中红黑树存储的Node小于该默认值，转化为链表
MIN_TREEIFY_CAPACITY:桶中的Node被树化时最小的hash表容量。(当桶中Node的数量大到需要变红黑树时，若hash表容量小于MIN_TREEIFY_CAPACITY时，此时应执行resize扩容操作这个MIN_TREEIFY_CAPACITY的值至少是TREEIFY_THRESHOLD的4倍。)
table:存储元素的数组，总是2的n次幂
entrySet:存储具体元素的集
size: HashMap中存储的键值对的数量
modCount: HashMap扩容和结构改变的次数。
threshold:扩容的临界值，= 容量 * 填充因子
loadFactor:填充因子
四、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);
}
}
五、常用方法：
添加、删除、修改操作:
- 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是否相等
- getOrDefault(N n,T t:)获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值(t)。
import java.util.HashMap;
class Main {
public static void main(String[] args) {
// 创建一个 HashMap
HashMap<Integer, String> sites = new HashMap<>();
// 往 HashMap 添加一些元素
sites.put(1, "Google");
sites.put(2, "Runoob");
sites.put(3, "Taobao");
System.out.println("sites HashMap: " + sites);
// key 的映射存在于 HashMap 中
// Not Found - 如果 HashMap 中没有该 key，则返回默认值
String value1 = sites.getOrDefault(1, "Not Found");
System.out.println("Value for key 1: " + value1);
// key 的映射不存在于 HashMap 中
// Not Found - 如果 HashMap 中没有该 key，则返回默认值
String value2 = sites.getOrDefault(4, "Not Found");
System.out.println("Value for key 4: " + value2);
}
}
元视图操作的方法:
- Set keySet():返回所有key构成的Set集合
- Collection values():返回所有value构成的Collection集合
- Set entrySet():返回所有key-value对构成的Set集合
代码实现：
Map
package Map;
import org.junit.Test;
import java.util.*;
public class MapTest {
@Test
public void testMap() {
Map map = new HashMap();
//添加操作
map.put(52,"WLM");
map.put(91,"CXY");
map.put(96,"YJJ");
//修改(替换：当key相同时，会替换掉原有的value)
map.put(91,"WLM");
System.out.println(map);
System.out.println("***********************");
Map map1 = new HashMap();
map1.put("AA",123);
map1.put("BB",123);
//putAll()
map.putAll(map1);
System.out.println(map);
System.out.println("***********************");
//remove(Object key)
Object value = map.remove("AA");//接收的为key所对应的value;
System.out.println(value);
System.out.println(map);
//clear()
map1.clear();
System.out.println(map1);//{}
}
@Test
public void testMap1() {
Map map = new HashMap();
map.put(52,"WLM");
map.put(91,"CXY");
map.put(96,"YJJ");
map.put("AA",123);
map.put("BB",123);
//Object get(Object key)
System.out.println(map.get(52));//WLM
//containsKey(Object key)
System.out.println(map.containsKey(96));//true
//containsValue(Object key)
System.out.println(map.containsValue("WRT")); //false
//size()
System.out.println(map.size());
}
@Test
public void testMap2() {
Map map = new HashMap();
map.put("WLM",52);
map.put("CXY",91);
map.put("YJJ",96);
map.put(123,"AA");
map.put(456,"BB");
//遍历所有的key集：keySet()
Set set = map.keySet();
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
System.out.println("********************************");
//遍历所有的value集：values()
Collection values = map.values();
for(Object value : values){
System.out.println(value);
}
System.out.println("********************************");
//遍历所有的key-value：entrySet()
//方式一：
Set set1 = map.entrySet();
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()) {
Object obj = iterator1.next();
//entrySet集合中的元素全是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey()+"--->"+entry.getValue());
//或者：Map.Entry entry = (Map.Entry) iterator1.next();
//System.out.println(entry);
}
System.out.println("********************************");
//方式二：
Set keySet = map.keySet();
Iterator iterator2 = keySet.iterator();
while (iterator2.hasNext()) {
Object key = iterator2.next();
Object value = map.get(key);
System.out.println(key+"--->"+value);
}
}
}
TreeMap
package TreeMap;
import org.junit.Test;
import java.util.*;
import java.util.Objects;
public class TreeMapTest {
//向TreeMap中添加key-value，要求key必须是由同一个类创建的对象。因为要按照key进行排序：自然排序、定制排序
@Test
public void test() {
TreeMap map = new TreeMap();
map.put(new Person("WLM"), 18);
map.put(new Person("YJJ"), 19);
map.put(new Person("CXY"), 16);
Set set1 = map.entrySet();
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()) {
Object obj = iterator1.next();
//entrySet集合中的元素全是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "--->" + entry.getValue());
//或者：Map.Entry entry = (Map.Entry) iterator1.next();
//System.out.println(entry);
}
}
//定制排序
@Test
public void test1() {
TreeMap map = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Person && o2 instanceof Person) {
Person person1 = (Person) o1;
Person person2 = (Person) o2;
return Integer.compare(person1.getAge(), person2.getAge());
}
throw new RuntimeException("输入的类型不匹配");
}
}
);
map.put(new Person("WLM",18), 52);
map.put(new Person("YJJ",19), 96);
map.put(new Person("CXY",16), 91);
Set set1 = map.entrySet();
Iterator iterator1 = set1.iterator();
while (iterator1.hasNext()) {
Object obj = iterator1.next();
//entrySet集合中的元素全是entry
Map.Entry entry = (Map.Entry) obj;
System.out.println(entry.getKey() + "--->" + entry.getValue());
//或者：Map.Entry entry = (Map.Entry) iterator1.next();
//System.out.println(entry);
}
}
}
class Person implements Comparable {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public Person() {
}
public String getName() {
return name;
}
public Person(String name) {
this.name = 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) {
System.out.println("Person equals()......");
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Person person = (Person) o;
return age == person.age && Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
//按名字从小到大排列,年龄从小到大排列
@Override
public int compareTo(Object o) {
if (o instanceof Person) {
Person person = (Person) o;
int result = this.name.compareTo(person.name);
if (result != 0) {
return result;
} else {
return Integer.compare(this.age, person.age);
}
} else {
throw new RuntimeException("输入的类型不匹配！");
}
}
}
Properties
package Properties;
import java.io.FileInputStream;
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 properties = new Properties();
fis = new FileInputStream("jdbc.properties");
properties.load(fis);//加载流对应的文件
String name = properties.getProperty("name");
String age = properties.getProperty("age");
System.out.println(name + "--->" + age);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
Collections工具类
Collections是一个操作Set、List和Map等集合的工具类
Collections中提供了一系列静态的方法对集合元素进行排序、查询和修改等操作,，还提供了对集合对象设置不可变、对集合对象实现同步控制等方法
排序操作:(均为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对象的所有旧值
代码实现：
package Collections;
import org.junit.Test;
import java.util.*;
public class CollectionsTest {
@Test
public void test(){
List list = new ArrayList();
list.add("WLM");
list.add("YJJ");
list.add("CXY");
list.add(123);
list.add(456);
//报异常：IndexOutOfBoundsException: Source does not fit in dest 原因：dest容量为0,与list不匹配
// List dest = new ArrayList();
List dest = Arrays.asList(new Object[list.size()]);
System.out.println(dest.size());//list.size();
Collections.copy(dest,list);
System.out.println(dest);
//返回list1即为线程安全的List
List list1 = Collections.synchronizedList(list);
}
}
