共计 8101 个字符，预计需要花费 21 分钟才能阅读完成。
汇合概述
java 汇合就像一个容器，这些对象能够是任意的数据类型，且长度可变。汇合依照其存储构造能够分为两大类，即单列汇合 Collection，和双列汇合 Map。
这两种汇合特点如下：
（1）Collection：单列汇合接口，用于存储一系列元素。
Collection 汇合有两个重要的子接口，别离是 List 和 Set。其中 List 汇合的特点是元素有序，可反复；Set 汇合的特点是元素无序并且不可反复。List 接口的次要实现类有 ArrayList 和 ListedList；Set 接口的次要实现类有 HashSet 和 TreeSet。
（2）Map：双列汇合的根接口，用于存储具备键（Key)，值（Value）映射关系的元素。
Map 汇合中每个元素都蕴含一对键值，并且 Key 是惟一的，在应用 Map 汇合时能够通过指的 Key 找到对应的 Value。Map 接口的次要实现类有 HashMap 和 TreeMap。
List 接口
List 接口继承于 Collection 接口，在 List 汇合中容许呈现反复的元素，在程序中能够通过索引来拜访汇合中的指定元素，另外 List 汇合还有一个特点就是存取有序。
ArrayList 汇合
ArrayList 外部封装了一个长度可变的数组对象（初始容量为 8，按 1.5 倍扩容），在 ArrayList 中进行增删改查效率会比拟低，然而在遍历和查找元素时显得十分高效。
LinkedList 汇合
为了克服 ArrayList 增删效率低的问题，能够用 LinkedList，该汇合内有一个双向循环链表，增删效率较高。
Collection 汇合遍历
Iterator 遍历汇合
Iterator 对象被称为迭代器，用来拜访 Collection 中的元素。在应用迭代器对汇合元素迭代是，如果调用了 remove 的办法去删除元素，，会出现异常。起因是汇合中删除元素会导致迭代器语气的迭代次数产生扭转，导致迭代器的后果不精确。
public class Test1 {public static void main(String[] args) {
// 创立 ArrayList 对象
ArrayList list = new ArrayList();
// 增加元素
list.add("data_1");
list.add("data_2");
list.add("data_3");
Iterator iterator = list.iterator();
while (iterator.hasNext()){//hasNext()判断汇合中是否存在下一个元素
Object object = iterator.next();
// 如果存在，则调用 next()将其取出，否则阐明曾经达到了汇合开端，进行遍历
System.out.println(object);
}
}
}
// 输入后果为
data_1
data_2
data_3
foreach 遍历汇合
foreach 是一种简介的 for 循环，也被称为加强 for 循环。foreach 循环用于遍历数组或汇合中的元素，具体语法格局如下
for( 容器中的元素类型 长期变量 : 容器变量）{// 执行语句}
public class Test1 {public static void main(String[] args) {
// 创立 ArrayList 对象
ArrayList list = new ArrayList();
// 增加元素
list.add("data_1");
list.add("data_2");
list.add("data_3");
for (Object object : list) {System.out.println(object);
}
}
}
foreach 也存在局限性，过后用 foreach 循环时，不能对汇合中元素进行批改。
JDK8 的 forEach 遍历汇合
在 JDK8 中，依据 Lambda 表达式的个性还减少了一个 forEach 办法来遍历汇合，演示如下
public class Test1 {public static void main(String[] args) {
// 创立 ArrayList 对象
ArrayList list = new ArrayList();
// 增加元素
list.add("data_1");
list.add("data_2");
list.add("data_3");
list.forEach(obj-> System.out.println("迭代器汇合元素"+obj));
}
}
// 输入后果为
迭代器汇合元素 data_1
迭代器汇合元素 data_2
迭代器汇合元素 data_3
Set 接口
Set 接口简介
Set 接口中的元素无序，并且保障存入的元素不会反复。Set 接口次要有两个实现类，别离是 HashSet 和 TreeSet，其中 HashSet 是依据对象的哈希值来确定元素汇合中的存储地位，因而具备良好的存取和查找性能。TreeSet 则以二叉树的形式来存储元素，它能够实现对汇合中的元素排序。
HashSet 汇合
HashSet 是 set 接口的一个实现类，它所存储的元素是不可反复的，并且元素都是无序的。当想 HashSet 汇合中增加元素时，首先会调用 hashcode 办法来确定元素的存储地位，而后再调用元素对象的 equals（）办法来确保该地位没有反复元素。
public class Test1 {public static void main(String[] args) {HashSet hashSet = new HashSet();
hashSet.add("Jack");
hashSet.add("Rose");
hashSet.add("Eve");
hashSet.add("Rose");
hashSet.forEach(obj-> System.out.println(obj));
}
}
// 输入后果为
Eve
Rose
Jack
向汇合中存入元素时，为了保障 HashSet 失常工作，要求在存入对象是，须要重写 Object 类中的 hashCode（）和 equals（）办法。上个例子将字符串存入 HashSet 时，String 类曾经默认重写了 hashCode 的办法，然而有时候传入自定义类型的对象存入 HashSet，须要重写办法。
package Demo01;
import java.util.ArrayList;
import java.util.*;
/**
* @author Dell
*/
public class Test1 {public static void main(String[] args) {HashSet hashSet = new HashSet();
hashSet.add(new Student("2","zhang"));
hashSet.add(new Student("8","name"));
hashSet.add(new Student("4","jack"));
hashSet.add(new Student("6","row"));
hashSet.forEach();}
}
class Student{
String id;
String name;
public Student(String id, String name) {
this.id = id;
this.name = name;
}
@Override
public String toString(){return id+" "+name;}
@Override
public int hashCode(){return id.hashCode();
}
@Override
public boolean equals(Object object){if(this == object){ // 判断是否是同一个对象
return true; // 如果是，返回 true
}
if(!(object instanceof Student)){ // 判断对象是为 Student 类型
return false; // 如果不是，返回 false
}
Student student = (Student) object; // 将对象强转为 Student 类型
boolean b = this.id.equals(student.id); // 判断 id 值是否雷同
return b; // 返回判断后果
}
}
// 输入后果为
[2 zhang, 4 jack, 6 row, 8 name]
TreeSet 接口
TreeSet 采纳均衡二叉树来存储元素，这样的构造能够保障 TreeSet 汇合中没有反复的元素，且能够排序。汇合中的元素在进行比拟时，都会调用 compareTo（）办法，该办法是 Comparable 定义的。在向 TreeSet 传入自定义数据时，没有实现 Comparable 接口。为了解决这个问题 java 提供了两种办法别离为天然排序和定制排序。
// 天然排序
package Demo01;
import java.util.ArrayList;
import java.util.*;
/**
* @author Dell
*/
public class Test1 {public static void main(String[] args) {TreeSet treeSet = new TreeSet();
treeSet.add(new Teacher("jack",18));
treeSet.add(new Teacher("rose",19));
treeSet.add(new Teacher("tom",19));
treeSet.add(new Teacher("rose",19));
System.out.println(treeSet);
}
}
// 定义 Teacher 类实现 Comparable 接口
class Teacher implements Comparable{
String name;
int age;
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString(){return name +":"+age;}
// 重写 Comparable 接口的 compareTo()的办法
@Override
public int compareTo(Object obj){Teacher teacher = (Teacher) obj;
// 定义比拟形式，先比拟年龄，再比拟名称 name
if(this.age- teacher.age>0){return 1;}
if(this.age- teacher.age==0){return this.name.compareTo(teacher.name);
}
return -1;
}
}
// 输入后果为
[jack:18, rose:19, tom:19]
Teacher 类实现了 Comparable 接口，并重写 compareTo（）办法。在 compareTo（）办法中，首先针对 age 值进行批改，依据比拟后果返回 - 1 和 1，当 age 雷同时，再对 name 进行比拟。老师 Teacher 对象首先依照年龄升序排序，年龄雷同时会依照姓名进行升序排序，并且 TreeSet 汇合会将反复的元素去掉。
// 定制排序
package Demo01;
import java.util.*;
/**
* @author Dell
*/
public class Test1 {public static void main(String[] args) {
// 1. 创立汇合时，传入 Comparator 接口实现定制排序规定
TreeSet treeSet = new TreeSet(new MyComparator());
treeSet.add("jack");
treeSet.add("hello");
treeSet.add("tom");
System.out.println(treeSet);
// 2. 创立汇合时，应用 Lambda 表达式定制排序规定
TreeSet treeSet1 = new TreeSet((obj1,obj2)->{String s1 = (String) obj1;
String s2 = (String) obj2;
return s1.length() - s2.length();
});
treeSet1.add("jack");
treeSet1.add("tom");
treeSet1.add("hello");
System.out.println(treeSet1);
}
}
class MyComparator implements Comparator{
@Override
public int compare(Object obj1, Object obj2){ // 定制排序形式
String str1 = (String) obj1;
String str2 = (String) obj2;
int temp = str1.length()-str2.length();
return temp;
}
}
Map 接口
Map 接口简介
Map 接口是一个双列汇合，它的每个元素都蕴含一个键对象 Key 和值对象 Value，键和值对象之间存在一种对应关系，称为映射。Map 中 key 和 value 能够是任意数据类型，并且键对象 Key 不容许反复，在拜访 Map 汇合中的元素时，只有指定了 Key，就能找到对应的 Value。
HashMap 汇合
HashMap 汇合时 Map 接口的一个实现类，它用于存储键值映射关系，该汇合的键和值容许为空，但键不能反复，且汇合中的元素是无序的。
Map 汇合遍历
Iterator 迭代器遍历 Map 汇合
应用 Iterator 遍历汇合须要先将 Map 汇合转换为 Iterator 接口对象，而后进行遍历。因为 Map 汇合中元素是有键值对形成的，所以应用 Iterator 遍历，有两种办法，即 keySet（）和 entrySet（）
keySet（）办法须要将 Map 汇合中所有的键对象转换为 Set 单列汇合，接着将含键对象的 Set 汇合转换为 Iterator 接口对象，而后遍历 Map 汇合中所有的键，再依据键获取相应的值。
// 该办法是 keySet()办法
import java.util.*;
/**
* @author Dell
*/
public class Test1 {public static void main(String[] args) {Map map = new HashMap();
map.put("3", "Jack");
map.put("1", "Rock");
map.put("2", "Tom");
Set keySet = map.keySet();// 获取键的汇合
Iterator iterator = keySet.iterator();// 迭代键的汇合
while (iterator.hasNext()) {Object key = map.keySet();
Object value = map.get(key);// 获取每个键所对应的值
System.out.println(key + ":" + value);
}
}
}
entrySet()办法将原有的 Map 汇合中的键值对作为一个整体返回 Set 汇合，接着将蕴含键值对对象的 Set 汇合转换为 Iterator 接口对象，而后获取汇合中的所有键值对映射关系，在从映射关系中取出键和值。
// 该办法是 entrySet()办法
package Demo01;
import java.util.*;
/**
* @author Dell
*/
public class Test1 {public static void main(String[] args) {Map map = new HashMap();
map.put("3", "Jack");
map.put("1", "Rock");
map.put("2", "Tom");
Set entrySet = map.entrySet();
Iterator iterator = entrySet.iterator();// 获取 Iterator 对象
while (iterator.hasNext()){Map.Entry entry = (Map.Entry)(iterator.next());// 获取汇合中键值对映射关系
Object key = entry.getKey();// 获取 Entry 中的键
Object value = entry.getValue();// 获取 Entry 中的值
System.out.println(key + ":" + value);
}
}
}
应用 forEach 办法遍历 Map 汇合
public class Test1 {public static void main(String[] args) {Map map = new HashMap();
map.put("3", "Jack");
map.put("1", "Rock");
map.put("2", "Tom");
map.forEach((key, value) -> System.out.println(key + ":" + value));
}
}
在 map 汇合中还提供了一个 values（）的办法，通过这个办法，能够间接获取 Map 中存储所有值的 Collection 汇合
public class Test1 {public static void main(String[] args) {Map map = new HashMap();
map.put("3", "Jack");
map.put("1", "Rock");
map.put("2", "Tom");
Collection values = map.values();// 获取 map 汇合中 values 值汇合对象
values.forEach(v-> System.out.println(v));
}
}
应用 LinkedHashMap 汇合保障元素增加程序
创立 LinkedHashMap 汇合，可保障存取程序统一。
Properties 汇合
Properties 汇合是 HashTable 的子类，Properties 次要用来存储字符串类型的键和值。
在文件目录中增加配置文件 文件名为 test.properties
上面来展现如何对 properties 配置文件进行读取和写入操作
Background = black
name = zhang
age = 19
package Demo01;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.util.Properties;
public class Test1 {public static void main(String[] args) throws Exception {
// 1. 通过 properties 进行属性文件读取操作
Properties pps = new Properties();
// 加载要读取的文件 test.properties
pps.load(new FileInputStream("test.properties"));
// 遍历 test.properties 键值对元素信息
pps.forEach((k,v)-> System.out.println(k +":"+ v));
// 2. 通过 properties 进行属性文件写入操作
// 指定要写入操作的文件名称和地位
FileOutputStream out = new FileOutputStream("test.properties");
// 向 properties 类文件进行希尔键值对信息
pps.setProperty("charset","UTF-8");
// 将此 properties 汇合中新增的键值对信息写入配置文件中
pps.store(out,"新增 charset 编码");
}
}
// 第一次输入后果为
background:black
name:zhang
age:19
// 第二次输入后果为
charset:UTF-8
background:black
name:zhang
age:19
最初
在文章的最初作者为大家整顿了很多材料！包含 java 外围知识点 + 全套架构师学习材料和视频 + 一线大厂面试宝典 + 面试简历模板 + 阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题 +Spring 源码合集 +Java 架构实战电子书等等！
有须要的敌人关注公众号：前程有光，自行下载即可！