集合

在开发的时候，如果需要存储多个数据，可以使用数组，不过数据是固定长度的，如果需要存储可变长度的多个数据，可以使用集合。集合提供存储空间可变的存储类型，存储的容量可以实时改变

集合分类

Collection 单列集合(接口)

List (接口)存储的值可以重复

ArrayList(实现类)

LinkedList(实现类)

Set(接口)存储的值不可重复

HashSet(实现类)

TreeSet(实现类)

Map 双列集合(接口)

HashMap(实现类)

TreeMap(实现类)

Collection

Collection 是单列集合的顶层接口，它表示一组对象，这些对象也称为 Collection 的元素

JDK 不提供接口的任何实现，但是提供更具体的子接口，比如 List Set 实现接口

Collection 集合的常用方法

方法名

说明

boolean add(E e)

添加元素

int size()

返回集合中元素的个数

boolean isEmpty()

判断集合是否为空

boolean contains(Object o)

判断集合中是否存在指定元素

void clear()

清空集合

boolean remove(Object o)

删除指定元素

Iterator 迭代器

迭代器是集合专用的遍历方式，通过集合对象的 iterator 方法获取

迭代器的常用方法

方法名

说明

next()

返回下一个元素

boolean hasNext()

判断是否可迭代

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

/**

* 迭代器

*/

public class IteratorDemo {

public static void main(String[] args) {

// 以多态的形式创建一个 Collection 对象

Collection list = new ArrayList<>();

// 给集合添加元素

list.add("i");

list.add("t");

list.add("e");

list.add("r");

// 创建一个迭代器

Iterator iter = list.iterator();

// 判断是否可迭代，如果可迭代

while (iter.hasNext()){

// 输出下一个元素

System.out.println(iter.next());

}

}

}

list

list 集合是可重复的，可以通过索引值访问集合中的元素

list 集合的常用方法

方法名

说明

void add(int index, E e)

添加元素

E get(int index)

获取元素

E set(index, E e)

设置元素

E remove(int index)

删除元素

ListIterator

ListIterator 是 list 集合的专属迭代器，通过集合的 ListIterator() 方法获取迭代器对象

ListIterator 在迭代期间可以修改集合，而且执行获取双向的迭代操作

ListIterator 中的常用方法

方法名

说明

void add(E e)

添加元素

E next()

返回迭代器中的下一个元素

boolean hasNext()

判断迭代器中是否有下一个元素

E pervious()

返回迭代器中的上一个元素

boolean hasPervious()

判断迭代器中是否有上一个元素

ListIterator 常用的应用示例

import java.util.ArrayList;

import java.util.ListIterator;

/**

* ListIterator

*/

public class Demo01 {

public static void main(String[] args) {

// 创建一个 list

ArrayList list = new ArrayList<>();

// 添加元素

list.add("h");

list.add("e");

list.add("l");

list.add("o");

// 创建一个 ListIterator

ListIterator listIter = list.listIterator();

// 判断迭代器中是否有下一个元素，如果有

while (listIter.hasNext()){

// 把迭代器中的下一个元素赋值给变量 s

String s = listIter.next();

// 判断如果下一个元素是 l

if ("l".equals(s)){

// 通过迭代器向集合中添加一个元素 l

listIter.add("l");

}

// 输入迭代器中的下一个元素

System.out.println(s);

}

System.out.println("~~~");

// 判断迭代器中是否有上一个元素，如果有

while (listIter.hasPrevious()){

// 输出迭代器中的上一个元素

System.out.println(listIter.previous());

}

}

}

数据结构

数据结构是计算机存储，组织数据的一种方式

栈

栈模型只有一个开口，数据==先进后出==

栈底元素：最先进入栈模型的元素

栈顶元素：最后进入栈模型的元素

进栈、压栈：数据进入栈模型的过程

出栈、弹栈：数据离开栈模型的过程

/**

* 栈

*/

public class Demo01 {

public static void main(String[] args) {

say(3);

}

private static void say (int num) {

System.out.println(num);

if (num > 1) {

say(num - 1);

}

System.out.println(num);

}

}

队列

队列模型，两端都有开口，数据==先进先出==

入队列：数据进入队列模型的过程

出队列：数据离开队列模型的过程

数组

数组查询、修改快，增加、删除慢

查询和修改数据通过索引定位，对于任意位置的数据耗时相同，查询效率高

增加数据，需要将插入位置之后的所有数据依次后移，效率低

删除数据，需要将删除位置之后的所有数据一次前移，效率低

链表

链表增加、删除快，查询、修改慢

节点：一个数据单元

指针域：用来存储节点地址的存储空间

数据域：用来存储实际数据的存储空间

List 集合实现类的特点

ArrayList 底层数据结构是数组，查询、修改快，添加、删除慢

LinkedList 底层数据结构是链表，添加、删除快，查询、修改慢

ArrayList

ArralList 类的常用方法

方法名

说明

public ArrayList()

无参构造方法，用于创建一个空集合

public boolean add(E e)

添加元素到集合的末尾

public void add(int index, E element)

添加元素到集合的指定位置

public E get(int index)

返回指定索引位置的元素

public int size()

返回集合的元素个数

public E set(int index, E element)

修改指定元素，返回修改的元素

publec boolean remmove(Object o)

删除指定元素，返回是否删除成功

public E remove(int index)

删除指定元素，返回被删除的元素

应用示例

import java.util.ArrayList;

/**

* Arraylist 的基本使用

*/

public class Demo01 {

public static void main(String[] args) {

// 调用无参构造方法，创建一个空集合

ArrayList list = new ArrayList<>();

// 添加元素到集合末尾

list.add("hello");

list.add("list");

// 打印集合，输出结果：[hello, list]

System.out.println(list);

// 遍历集合中的元素，使用 size() 和 get()

for (int i = 0; i < list.size(); i++) {

System.out.println(list.get(i));

}

// 遍历集合中的元素，使用 foreach

for (String str:list) {

System.out.println(str);

}

// 添加元素到集合的指定位置

list.add(1, "world");

// 输出结果：[hello, world, list]

System.out.println(list);

// set(int index, E element) 修改集合中的元素

String se = list.set(2, "ArrayList");

// 输出结果：list

System.out.println(se);

// 输出结果：[hello, world, ArrayList]

System.out.println(list);

// remove(Object o) 删除指定元素，返回是否删除成功

boolean re = list.remove("ArrayList");

// 输出结果：true

System.out.println(re);

// 输出结果：[hello, world]

System.out.println(list);

// remove(int index) 删除指定元素，返回删除的元素

String re1 = list.remove(1);

// 输出结果：world

System.out.println(re1);

// 输出结果：[hello]

System.out.println(list);

}

}

使用 ArrayList 存储对象

/**

* 定义一个学生类

*/

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;

}

@Override

public String toString() {

return "Student{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

}

/**

* 使用集合存储学生对象

*/

import java.util.ArrayList;

import java.util.Scanner;

public class Demo03 {

public static void main(String[] args) {

ArrayList stuList = new ArrayList<>();

String name;

int age;

for (int i = 0; i < 3; i++) {

System.out.println("请输入学生姓名");

name = new Scanner(System.in).next();

System.out.println("请输入学生年龄");

age = new Scanner(System.in).nextInt();

stuList.add(new Student(name, age));

}

System.out.println(stuList);

}

}

LinkedList

LinkedList 类的常用方法

方法名

说明

public void addFirst(E e)

在列表的第一个位置添加元素

public void addLast(E e)

在列表的最后一个位置添加元素

public E getFirst()

获取列表的第一个元素

public E getLast()

获取列表的最后一个元素

public E removeFirst()

删除列表的第一个元素，返回删除的元素

public E removeLast()

删除列表的最后一个元素，返回删除的元素

应用示例

import java.util.LinkedList;

/**

* LinkedList

*/

public class Demo01 {

public static void main(String[] args) {

// 创建一个 LinkedList 对象

LinkedList linkedList = new LinkedList<>();

// 添加元素

linkedList.add("e");

linkedList.add("l");

linkedList.add("l");

// 添加元素到第一个位置

linkedList.addFirst("h");

// 添加元素到最后一个位置

linkedList.addLast("o");

// 输出结果：[h, e, l, l, o]

System.out.println(linkedList);

// 获取第一个元素，输出结果：h

System.out.println(linkedList.getFirst());

// 获取最后一个元素，输出结果：o

System.out.println(linkedList.getLast());

// 删除第一个元素，输出结果：h

System.out.println(linkedList.removeFirst());

// 输出结果：[e, l, l, o]

System.out.println(linkedList);

// 删除最后一个元素，输出结果：o

System.out.println(linkedList.removeLast());

// 输出结果：[e, l, l]

System.out.println(linkedList);

}

}

Set

Set 是一个接口，需要通过实现类来对其进行操作

Set 集合的特点：

不包含重复的元素

没有带索引的方法，不能通过普通的 for 循环利用索引的方式进行遍历

哈希值

哈希值是 JVM 根据对象的地址或者字符串或者数值计算出来的一个 int 类型的数值

Object 类中有一个可以获取对象哈希值的方法：public int hashCode()

哈希值的特点：

同一个对象的哈希值是相同的

一般情况下，不同的对象，哈希值是不同的，但是有特殊情况

哈希表

哈希表是通过数组 + 链表的形式实现的

任何数%16之后的结果都小于15，然后再取绝对值，得到0～15范围的数值

哈希表的底层是一个拥有16个存储空间的数组，对元素取哈希值，再%16，再取绝对值，再根据得到的值，存储到数组对应的位置，比如有一个元素，经过取哈希值，%16，取绝对值之后得到的值是0，那就把它存储在数据的第一个位置。相同位置的元素以链表的形式连接起来。

image

HashSet

HashSet 集合的底层数据结构是哈希表

HashSet 集合的特点

不包含重复的元素

存、取的顺序不一致

没有带索引参数的方法，不能使用索引进行遍历

import java.util.HashSet;

import java.util.Iterator;

/**

* HashSet

*/

public class Demo01 {

public static void main(String[] args) {

// 创建 HashSet 对象

HashSet hashSet = new HashSet<>();

// 添加元素

hashSet.add("h");

hashSet.add("e");

hashSet.add("l");

hashSet.add("l");

hashSet.add("o");

// 输出结果：[e, h, l, o]

System.out.println(hashSet);

// 遍历，使用 foreach

for (String str : hashSet) {

System.out.println(str);

}

// 遍历，使用迭代器

// 创建迭代器对象

Iterator iter = hashSet.iterator();

// 如果迭代器中有下一个元素

while (iter.hasNext()) {

// 输出迭代器中的下一个元素

System.out.println(iter.next());

}

}

}

LinkedHashSet

LinkedHashSet 集合底层数据结构是哈希表 + 链表

LinkedHashSet 集合的特点：

存、取的顺序一致

没有重复的元素

import java.util.LinkedHashSet;

/**

* LinkedHashSet

*/

public class Demo01 {

public static void main(String[] args) {

// 创建 LinkedHahSet 对象

LinkedHashSet lhSet = new LinkedHashSet<>();

// 添加元素

lhSet.add("h");

lhSet.add("e");

lhSet.add("l");

lhSet.add("l");

lhSet.add("o");

// 输出结果：[h, e, l, o]

System.out.println(lhSet);

}

}

TreeSet

TreeSet 集合可以按照一定的排序规则对元素进行排序

TreeSet 集合的特点：

没有重复的元素

没有索引

自然排序示例

import java.util.TreeSet;

/**

* TreeSet

* 自然排序

*/

public class Demo01 {

public static void main(String[] args) {

// 创建一个 TreeSet 对象

TreeSet tSet = new TreeSet<>();

// 添加元素

tSet.add(2);

tSet.add(4);

tSet.add(3);

tSet.add(1);

// 输出结果：[1, 2, 3, 4]

System.out.println(tSet);

}

}

使用接口对对象进行排序示例

/**

* 定义一个类，实现 Comparable 接口

*/

public class Stdent implements Comparable {

private String name;

private int age;

public Stdent() {

}

public Stdent(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 "Student{" +

"name='" + name + '\'' +

", age=" + age +

'}';

}

@Override

public int compareTo(Stdent stu) {

// 比较年龄

int re = this.getAge() - stu.getAge();

// 如果年龄相等，返回比较姓名的结果，如果年龄不相等，直接返回比较年龄的结果

return re == 0 ? this.getName().compareTo(stu.getName()) : re;

}

}

import java.util.TreeSet;

/**

* TreeSet

* 使用接口对对象排序

*/

public class Demo02 {

public static void main(String[] args) {

// 创建 TreeSet 对象

TreeSet tSet = new TreeSet<>();

// 添加元素

tSet.add(new Stdent("小明", 19));

tSet.add(new Stdent("小红", 18));

tSet.add(new Stdent("张三", 20));

// 输出结果：[Student{name='小红', age=18}, Student{name='小明', age=19}, Student{name='张三', age=20}]

System.out.println(tSet);

}

}

泛型

泛型是提供编译时类型安全的检测机制。该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说操作的数据类型可以被指定为一个参数

泛型可以应用在类、方法和接口中，分别称之为泛型类，泛型方法和泛型接口

泛型的定义格式

指定一种数据类型

指定多种数据类型，多种类型之间用逗号分隔

使用泛型的好处

把运行时期的问题提前到了编译时期，可以更早的发现问题

避免强制类型转换的问题

泛型类

泛型类的定义格式

修饰符 class 类名{}

比如:

public class Generic{}

泛型类示例

/**

* 定义一个泛型类

*/

public class GenericClass {

private T t;

public T getT() {

return t;

}

public void setT(T t) {

this.t = t;

}

}

/**

* 泛型类

*/

public class GenericClassDemo {

public static void main(String[] args) {

// 使用泛型类传递 String

Generic strG = new Generic<>();

strG.setT("hello");

System.out.println(strG.getT());

// 使用泛型类传递 int

Generic intG = new Generic<>();

intG.setT(123);

System.out.println(intG.getT());

// 使用泛型类传递 Student

Generic stuG = new Generic<>();

stuG.setT(new Student("小明", 18));

System.out.println(stuG.getT());

}

}

泛型方法

泛型方法的定义格式

​ 修饰符 返回值类型 方法名(数据类型 变量名) {}

比如

​ public void show(T t){}

泛型方法示例

/**

* 定义一个泛型方法

*/

public class GenericMethod {

public void show(T t) {

System.out.println(t);

}

}

public class GenericMethodDemo {

public static void main(String[] args) {

GenericMethod genericMethod = new GenericMethod();

genericMethod.show("String");

genericMethod.show(123);

genericMethod.show(3.14);

}

}

泛型接口

泛型接口的定义格式

​ 修饰符 interface 接口名{}

比如：

​ public interface GenericInterface{}

泛型接口示例

/**

* 定义一个泛型接口

*/

public interface GenericInterface {

void show(T t);

}

/**

* 泛型接口的实现类

*/

public class GenericInterfaceClass implements GenericInterface {

@Override

public void show(T t) {

System.out.println(t);

}

}

public class GenericInterfaceDemo {

public static void main(String[] args) {

GenericInterfaceClass strInter = new GenericInterfaceClass<>();

strInter.show("String");

GenericInterfaceClass intInter = new GenericInterfaceClass<>();

intInter.show(123);

GenericInterface douInter = new GenericInterface() {

@Override

public void show(Double dou) {

System.out.println(dou);

}

};

douInter.show(3.14);

}

}

泛型通配符

泛型通配符 >

​ 比如 List> 表示未知类型的 List ，它的元素可以匹配任何数据类型

泛型通配符的上限 extend 数据类型>

​ 比如 List extend Number 表示类型可以是 Number 或者其子类

泛型通配符的下限 super 数据类型>

​ 比如 Lits super Number> 表示类型可以是 Number 或者器父类

通配符示例

import java.util.ArrayList;

import java.util.List;

/**

* 泛型通配符

*/

public class GenericTpf {

public static void main(String[] args) {

// 泛型通配符的上限

List extends Number> list1 = new ArrayList();

List extends Number> list2 = new ArrayList();

// Object 超过了 Number 的上限，所以会报错

// List extends Number> list3 = new ArrayList();

// 泛型通配符的下限

List super Number> list4 = new ArrayList();

// Integer 超过了 Number 的下限，所以会报错

// List super Number> list5 = new ArrayList();

}

}

可变长参数的常用方法

方法名

说明

public static List asList(T...a)

返回由指定数组生成的固定长度的Arrays集合

public static List of(E...e)

返回包含任意个元素的不可变List集合

public static Set of(E...e)

返回包含任意个元素的不可变Set集合

示例

import java.util.Arrays;

import java.util.List;

import java.util.Set;

/**

* 可变长参数常用方法

*/

public class Kbc {

public static void main(String[] args) {

// 通过 asList() 得到的集合，不支持增、删，可以修改

List list1 = Arrays.asList("one", "two", "three");

// 修改

list1.set(0, "1");

// 输出结果：[1, two, three]

System.out.println(list1);

// 通过 List.of() 方法得到的集合，不支持增、删、改

List list2 = List.of("one", "two", "three");

// 通过 Set.of() 方法得到的集合，也不支持增、删、改

Set set1 = Set.of("one", "two", "three");

}

}

Map

集合学到这里，总结下来 Java 中的 List 对应 python 中的 list , Set 对应 python 中的 set ，而 Map 对应 python 中的 dict

总的来说，List 存的值可以重复，Set 存的值不能重复，Map 存的是键值对

Map 中的常用方法

方法名

说明

put(key value)

增加或修改元素，当key不存在时，是增加，当key以存在时，是修改

remove(key)

删除元素

clear()

清空集合

containsKey(key)

判断集合中是否包含指定的键

containsValue(value)

判断集合中是否包含指定的值

isEmpty()

判断集合是否为空

size()

返回集合的长度

get(key)

根据键获取值

keySet()

返回所有键组成的集合

values()

返回所有值组成的集合

entrySet()

返回所有键值对组成的集合

Map 常用方法示例

import java.util.HashMap;

import java.util.Map;

/**

* Map 的常用方法

*/

public class Demo01 {

public static void main(String[] args) {

// 以多态的形式，通过 HashMap 创建一个 Map 对象

Map map = new HashMap<>();

// 增加元素

map.put(01, "小明");

map.put(02, "小红");

map.put(03, "张三");

// 输出结果：{1=小明, 2=小红, 3=张三}

System.out.println(map);

// 修改元素

map.put(03, "小黑");

// 输出结果：{1=小明, 2=小红, 3=小黑}

System.out.println(map);

// 通过 key 获取对应的 value ，输出结果：小红

System.out.println(map.get(02));

// 通过 keySet() 方法获取所有 key 组成的集合，输出结果：[1, 2, 3]

System.out.println(map.keySet());

// 通过 values() 方法获取所有 value 组成的集合，输出结果：[小明, 小红, 小黑]

System.out.println(map.values());

// 通过 entrySet() 方法获取所有键值对组成的集合，输出结果：[1=小明, 2=小红, 3=小黑]

System.out.println(map.entrySet());

/*

遍历键值对，输出结果：

1 小明

2 小红

3 小黑

*/

for (Map.Entry obj : map.entrySet()) {

System.out.println(obj.getKey() + " " + obj.getValue());

}

// 判断是否存在指定的键，输出结果：true

System.out.println(map.containsKey(01));

// 判断是否存在指定的值，输出结果：false

System.out.println(map.containsValue("张三"));

// 判断集合是否为空，输出结果：false

System.out.println(map.isEmpty());

// 返回集合的长度，输出结果：3

System.out.println(map.size());

// 删除元素，输出结果：小黑

System.out.println(map.remove(03));

// 清空集合

map.clear();

// 输出结果：{}

System.out.println(map);

}

}

Map 存储学生对象示例

import java.util.HashMap;

import java.util.Set;

/**

* Map 存储学生对象

*/

public class Demo02 {

public static void main(String[] args) {

// 创建一个 HashMap 对象

HashMap hm = new HashMap<>();

// 添加元素

hm.put(01, new Student("小明", 19));

hm.put(02, new Student("小红", 18));

hm.put(03, new Student("小黑", 20));

/*

遍历，输出结果：

1 小明 19

2 小红 18

3 小黑 20

*/

Set keySet = hm.keySet();

for (Integer key : keySet) {

Student stuObj = hm.get(key);

System.out.println(key + " " + stuObj.getName() + " " + stuObj.getAge());

}

}

}

ArrayList 存储 HashMap 示例

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Set;

/**

* ArrayList 中存储 HashMap

*/

public class Demo03 {

public static void main(String[] args) {

// 创建一个 ArrayList 对象

ArrayList> arrayList = new ArrayList<>();

// 创建一个 HashMap 对象

HashMap hm01 = new HashMap<>();

// 添加元素

hm01.put(001, "a");

hm01.put(002, "b");

// 创建一个 HashMap 对象

HashMap hm02 = new HashMap<>();

// 添加元素

hm02.put(001, "c");

hm02.put(002, "d");

// 创建一个 HashMap 对象

HashMap hm03 = new HashMap<>();

// 添加元素

hm03.put(001, "e");

hm03.put(002, "f");

// 把 3 个 map 添加到 arrayList

arrayList.add(hm01);

arrayList.add(hm02);

arrayList.add(hm03);

// 遍历 arrayList ，获取到每个 map

for (HashMap hm : arrayList) {

System.out.println(hm);

// 获取到每个 map 的 key 组成的集合

Set keySet = hm.keySet();

// 遍历 key 组成的集合，得到每个 key

for (Integer key : keySet) {

// 获取每个 key 对应的 value

String value = hm.get(key);

System.out.println(" " + key + " " + value);

}

}

}

}

HashMap 存储 ArrayList 示例

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Set;

/**

* HashMap 存储 ArrayList

*/

public class Demo04 {

public static void main(String[] args) {

// 创建一个 HashMap 对象

HashMap> hm = new HashMap<>();

// 创建一个 ArrayList 对象

ArrayList arrayList01 = new ArrayList<>();

// 添加元素

arrayList01.add("a");

arrayList01.add("b");

// 添加 arrayList01 到 HastMap

hm.put(01, arrayList01);

// 创建一个 ArrayList 对象

ArrayList arrayList02 = new ArrayList<>();

// 添加元素

arrayList02.add("c");

arrayList02.add("d");

// 添加 arrayList01 到 HastMap

hm.put(02, arrayList02);

// 创建一个 ArrayList 对象

ArrayList arrayList03 = new ArrayList<>();

// 添加元素

arrayList03.add("e");

arrayList03.add("f");

// 添加 arrayList01 到 HastMap

hm.put(03, arrayList03);

// 获取到 HashMap 中的所有 key 组成的集合

Set keySet = hm.keySet();

for (Integer key : keySet){

// 根据 key 获取到对应的 values ，这里获取到的是每个 arrayList

ArrayList list = hm.get(key);

System.out.println(list);

// 遍历每个 list 中的元素

for (String str : list) {

System.out.println(" " + str);

}

}

}

}

Collections

集合工具类

常用方法

方法名

说明

sort()

排序

reverse()

倒序

shuffle()

乱序

示例

import java.util.ArrayList;

import java.util.Collections;

/**

* Collections 常用方法

*/

public class Demo {

public static void main(String[] args) {

// 创建 ArrayList 对象

ArrayList list = new ArrayList<>();

// 添加元素

list.add(2);

list.add(1);

list.add(3);

// 输出结果：[2, 1, 3]

System.out.println(list);

// 排序

Collections.sort(list);

// 输出结果：[1, 2, 3]

System.out.println(list);

// 倒序

Collections.reverse(list);

// 输出结果：[3, 2, 1]

System.out.println(list);

// 乱序

Collections.shuffle(list);

// 输出结果：[3, 1, 2]

System.out.println(list);

}

}

Properties

Properties 与 HashMap 的用法类似，常与IO流一起使用

import java.util.Properties;

import java.util.Set;

/**

* Properties

*/

public class Demo {

public static void main(String[] args) {

Properties properties = new Properties();

// 添加元素

properties.put("1", "小明");

properties.put("2", "小红");

properties.put("3", "张三");

// 获取 keys

Set keys = properties.stringPropertyNames();

for (String key : keys) {

// 根据 key 获取 value

String value = properties.getProperty(key);

System.out.println(key + " " + value);

}

}

}

Properties 结合 IO 流读写文件

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.util.Properties;

/**

* 新建一个 test.txt 空文件，使用 Properties 结合 IO 写入，读取文件

*/

public class Demo02 {

public static void main(String[] args) throws IOException {

writeFile();

readFile();

}

private static void writeFile() throws IOException {

// 创建 Properties 对象

Properties prop = new Properties();

// 添加元素

prop.put("01", "小明");

prop.put("02", "小红");

prop.put("03", "小黑");

// 创建 FileWriter IO 流

FileWriter fw = new FileWriter("/Users/Desktop/test.txt");

// 将 prop 中的内容写入到文件

prop.store(fw, "test writefile");

// 关闭流

fw.close();

}

private static void readFile() throws IOException {

// 创建 Properties 对象

Properties prop = new Properties();

// 创建 FileReader IO 流

FileReader fr = new FileReader("/Users/Desktop/test.txt");

// 读取文件内容到 prop

prop.load(fr);

// 关闭流

fr.close();

// 输出结果：{01=小明, 02=小红, 03=小黑}

System.out.println(prop);

}

}

image