汇合概述
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架构实战电子书等等！
有须要的敌人关注公众号：前程有光，自行下载即可！
发表回复