一.集合
1.概念
在java中每一个不同的集合，底层会对应不同的数据结构。往不同的集合中 存储元素，等于将数据放到了不同的数据结构当中。
数据结构：数据存储的结构就是数据结构。不同的数据结构，数据存储方式不同。
2.集合与数组
1.相同点
都是容器,可以存储多个数据
2.不同点
- 数组的长度是不可变的,集合的长度是可变的
- 数组可以存基本数据类型和引用数据类型
集合只能存引用数据类型,如果要存基本数据类型,需要存对应的包装类。
引用数据类型（存储的为对象的内存地址）
3.装箱拆箱
1.手动装箱
int x = 90; //声明基础数据类型变量
Integer integer = new Integer(x); //声明Integer包装类 把int类型的x变量包装到Integer中
ArrayList list = new Arraylist; //创建ArrayList集合
list.add(integer); //将Integer包装类添加到list集合中(这种手动把int装到list里的操作，是比较麻烦的 所以后面推出了 自动装箱)
System.out.print(list); //输出list集合对象(也可以写成 list.toString(),输出的原理是调用了重写的toString方法)
2.自动装箱
int i = 99; //声明基础数据类型int变量
ArrayList list = new ArrayList();
list.add(i); //触发自动装箱，int类型自动转换成 Integer
System.out.println(list);
3.自动拆箱
public class Main{
public static void main(String[] args){
Integer int1 = 50;
Integer int2 = 50;
Integer int3 = 500;
Integer int4 = 500;
System.out.println(int1 == int2);//true
System.out.println(int3 == int4);//false
//在一定范围内，相同值只创建一个对象。
//==比较的是地址值
}
}
二.Collection集合
1.概述
-
是单例集合的顶层接口,它表示一组对象,这些对象也称为Collection的元素
-
JDK 不提供此接口的任何直接实现.它提供更具体的子接口(如Set和List)实现
2.创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
// 创建一个集合对象
//Collection c = new Collection(); // 接口是抽象的，无法实例化。
// 类的引用指向子类的对象，形成多态
Collection c = new ArrayList();
//具体的实现类
Collection<String> c = new ArrayList<>();
3.Collection集合常用方法
- boolean add(E e) 添加元素
- boolean remove(Object o) 从集合中移除指定的元素
- boolean removeIf(Object o) 根据条件进行移除
- void clear() 清空集合中的元素 boolean
- contains(Object o) 判断集合中是否存在指定的元素
- boolean isEmpty() 判断集合是否为空
- int size() 集合的长度，也就是集合中元素的个数
import java.util.ArrayList;
import java.util.Collection;
public class Demo {
public static void main(String[] args) {
//父类的引用指向子类的对象，形成多态
Collection<String> con = new ArrayList<>();
//追加的方式添加元素
con.add("1");
con.add("2");
con.add("3");
con.add("4");
con.add("5");
//删除,通过元素名称删除元素
System.out.println(con.remove("1"));//true
//判断集合中是否包含指定参数元素
System.out.println(con.contains("1")); //false
System.out.println(con.contains("3")); //true
//获取集合中元素个数
System.out.println(con.size());//4
//判断是否为空
System.out.println(con.isEmpty());//false
//清空集合
con.clear();
//判断是否为空
System.out.println(con.isEmpty());//true
System.out.println(con);//打印集合的元素
//输出[]
}
}
4.Collection集合的遍历
1.迭代器
Iterator中的常用方法
- boolean hasNext(): 判断当前位置是否有元素可以被取出
- E next():获取当前位置的元素,将迭代器对象移向下一个索引位置
集合专属的遍历工具
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class InteratorDemo1 {
public static void main(String[] args) {
//创建集合对象
Collection<String> c = new ArrayList<>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
c.add("javaee");
//Iterator<E> iterator()：返回此集合中元素的迭代器，通过集合的iterator()方法得到
Iterator<String> it = c.iterator();
//用while循环改进元素的判断和获取
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
}
迭代器中删除的方法
- void remove(): 删除迭代器对象当前指向的元素
import java.util.ArrayList;
import java.util.Iterator;
public class IteratorDemo2 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
if("b".equals(s)){
//指向谁,那么此时就删除谁.
it.remove();
}
}
System.out.println(list);
}
2.for循环遍历
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("b");
list.add("c");
list.add("d");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
3.增强for循环
import java.util.ArrayList;## 标题
public class Demo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
list.add("f");
//1.数据类型一定是集合或者数组中元素的类型
//2.str仅仅是一个变量名而已,在循环的过程中,依次表示集合或者数组中的每一个元素
//3.list就是要遍历的集合或者数组
for(String str : list){
System.out.println(str);
}
}
}
三.List集合
1.概述
定义
List接口继承自Collection接口，是单列集合的一个重要分支，习惯性的会将实现了List接口的对象称为List集合。
List集合的特点
- List集合中允许出现重复元素
- 所有元素是以一种线性方式进行存储的，在程序中可以通过索引（类似于数组中的元素角标）来访问集合中的元素
- 元素有序，即元素的存入顺序和取出顺序一致
2.List集合常用方法
- public void addFirst(E e) 在该列表开头插入指定的元素
- public void addLast(E e) 将指定的元素追加到此列表的末尾
- public E getFirst() 返回此列表中的第一个元素
- public E getLast() 返回此列表中的最后一个元素
- public E removeFirst() 从此列表中删除并返回第一个元素
- public E removeLast() 从此列表中删除并返回最后一个元素
- void add(int index,Object element) 将元素element插入在List集合的指定索引位置
- boolean addAll(int index,Collection c) 将集合c包含的所有元素插入到List集合的指定索引位置
- Object get(int index) 返回集合索引index处的元素
- Object remove(int index) 删除index索引处的元素
- Object set(int index,Object element)
将索引index处元素替换成element元素，并将替换后的元素返回 - int indexOf(Object o) 返回对象o在List集合中首次出现的位置索引
- int lastIndexOf(Object o) 返回对象o在List集合中最后一次出现的位置索引
- List subList(int fromIndex,int toIndex)
返回从索引fromIndex(包括)到toIndex(不包括)处所有元素集合组成的子集合 - Object[] toArray() 将集合元素转换成数组
- default void sort(Comparator<? super E>c) 根据指定的比较器规则对集合元素排序
import java.util.List;
import java.util.ArrayList;
public class ListDemo1 {
public static void main(String[] args){
//创建集合对象
List<String> list = new ArrayList<String>();
list.add("aaa");
list.add("bbb");
//void add(int index,Object element) 将元素element插入在List集合的指定索引位置
list.add(1,"ccc");
System.out.println(list); //[aaa,ccc,bbb]
//Object get(int index) 返回集合索引index处的元素
String str = list.get(0);
System.out.println(str);
//Object remove(int index) 删除index索引处的元素
String del = list.remove(0);
System.out.println(del);
System.out.println(list);
//Object set(int index,Object element)将索引index处元素替换成element元素，并将替换后的元素返回
String old = list.set(1,"ddd");
System.out.println(old);
System.out.println(list);
//int indexOf(Object o) 返回对象o在List集合中首次出现的位置索引
int index = list.indexOf("ddd");
System.out.println(index);
//int lastIndexOf(Object o) 返回对象o在List集合中最后一次出现的位置索引
list.add("ddd");
System.out.println(list);
index = list.lastIndexOf("ddd");
System.out.println(index);
//List subList(int fromIndex,int toIndex) 返回从索引fromIndex(包括)到toIndex(不包括)处所有元素集合组成的子集合
List<String> list2 = list.subList(1,list.size()-1);
System.out.println(list2);
//Object[] toArray() 将集合元素转换成数组
Object[] arr = list.toArray();
for(int i=0;i<arr.length;i++)
{
System.out.println(arr[i]);
}
//boolean addAll(int index,Collection c) 将集合c包含的所有元素插入到List集合的指定索引位置
List<String> List2 = new ArrayList<String>();
list2.add("aaa");
list2.add("eee");
list2.addAll(1,list);
//list2:[aaa,aaa,bbb,ccc,eee]
System.out.println(list2);
/*
[aaa, ccc, bbb]
aaa
aaa
[ccc, bbb]
bbb
[ccc, ddd]
1
[ccc, ddd, ddd]
2
[ddd]
ccc
ddd
*/
}
}
3.List接口的实现类:ArrayList
底层是数组结构实现，查询快、增删慢
特有方法
- void add(int index,E element) 在此集合中的指定位置插入指定的元素
- E remove(int index) 删除指定索引处的元素，返回被删除的元素
- E set(int index,E element) 修改指定索引处的元素，返回被修改的元素
- E get(int index) 返回指定索引处的元素
4.List接口的实现类:LinkedList
底层是链表结构实现，查询慢、增删快
特有方法
- public void addFirst(E e) 在该列表开头插入指定的元素
- public void addLast(E e) 将指定的元素追加到此列表的末尾
- public E getFirst() 返回此列表中的第一个元素
- public E getLast() 返回此列表中的最后一个元素
- public E removeFirst() 从此列表中删除并返回第一个元素
- public E removeLast() 从此列表中删除并返回最后一个元素
5.区别
链表的优点：
由于链表上的元素在空间存储上内存地址不连续。
所以随机增删元素的时候不会有大量元素位移，因此随机增删效率较高。
链表的缺点：
不能通过数学表达式计算被查找元素的内存地址，每一次查找都是从头
节点开始遍历，直到找到为止。所以LinkedList集合检索/查找的效率
较低。
ArrayList：把检索发挥到极致。（末尾添加元素效率还是很高的。）
LinkedList：把随机增删发挥到极致。
加元素都是往末尾添加，所以ArrayList用的比LinkedList多。
四.Set集合
1.特点
- 不允许包含重复的值
- 没有索引（就不能使用普通的for循环进行遍历）
2.应用
import java.util.Set;
import java.util.TreeSet;
import java.util.Iterator;
public class Demo {
public static void main(String[] args) {
//创建集合对象
Set<String> set = new TreeSet<>();
//添加元素
set.add("ccc");
set.add("aaa");
set.add("aaa");
set.add("bbb");
// for (int i = 0; i < set.size(); i++) {
// //Set集合是没有索引的，所以不能使用通过索引获取元素的方法
// }
//遍历集合
//interaor
Iterator<String> it = set.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
//增强for循环
for (String s : set) {
System.out.println(s);
}
}
}
3.TreeSet集合
特点
- 不可以存储重复元素
- 没有索引
- 可以将元素按照规则进行排序
1.TreeSet()：根据其元素的自然排序进行排序
2. TreeSet(Comparator comparator) ：根据指定的比较器进行排序
两种比较方式
两种比较方式小结
- 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
- 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序。
当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议实现Comparable接口。
如果比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口。
两种方式中关于返回值的规则
- 如果返回值为负数，表示当前存入的元素是较小值，存左边
- 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
- 如果返回值为正数，表示当前存入的元素是较大值，存右边
Comparable接口
案例需求
存储学生对象并遍历，创建TreeSet集合使用无参构造方法
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
1.使用空参构造创建TreeSet集合
用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的。
2.自定义的Student类实现Comparable接口
自然排序，就是让元素所属的类实现Comparable接口
3.重写compareTo(T o)方法
重写接口中compareTo方法 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
public class Student implements Comparable<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 +
'}';
}
@Override
public int compareTo(Student o) {
//按照对象的年龄进行排序
//主要判断条件: 按照年龄从小到大排序
int result = this.age - o.age;
//次要判断条件: 年龄相同时，按照姓名的字母顺序排序
result = result == 0 ? this.name.compareTo(o.getName()) : result;
return result;
}
}
import java.util.Set;
import java.util.TreeSet;
public class Demo {
public static void main(String[] args) {
//创建集合对象
TreeSet<Student> ts = new TreeSet<>();
//创建学生对象
Student s1 = new Student("zhangsan",28);
Student s2 = new Student("lisi",27);
Student s3 = new Student("wangwu",29);
Student s4 = new Student("zhaoliu",28);
Student s5 = new Student("qianqi",30);
//把学生添加到集合
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
//遍历集合
for (Student student : ts) {
System.out.println(student);
}
}
}
Comparator接口
案例需求
存储老师对象并遍历，创建TreeSet集合使用带参构造方法
要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
实现步骤
1.用TreeSet集合存储自定义对象，带参构造方法使用的是比较器排序对元素进行排序的。
2. 比较器排序，就是让集合构造方法接收Comparator的实现类对象，重写compare(T o1,T o2)方法
3.重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写。
public class Teacher {
private String name;
private int age;
public Teacher() {
}
public Teacher(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 "Teacher{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
import java.util.TreeSet;
import java.util.Comparator;
public class TeacherDemo1 {
public static void main(String[] args) {
//创建集合对象
TreeSet<Teacher> ts = new TreeSet<>(new Comparator<Teacher>() {
@Override
public int compare(Teacher o1, Teacher o2) {
//o1表示现在要存入的那个元素
//o2表示已经存入到集合中的元素
//主要条件
int result = o1.getAge() - o2.getAge();
//次要条件
result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
return result;
}
});
//创建老师对象
Teacher t1 = new Teacher("zhangsan",23);
Teacher t2 = new Teacher("lisi",22);
Teacher t3 = new Teacher("wangwu",24);
Teacher t4 = new Teacher("zhaoliu",24);
//把老师添加到集合
ts.add(t1);
ts.add(t2);
ts.add(t3);
ts.add(t4);
//遍历集合
for (Teacher teacher : ts) {
System.out.println(teacher);
}
}
}
4. HashSet集合
特点
- 底层数据结构是哈希表
- 存取无序
- 不可以存储重复元素
- 没有索引,不能使用普通for循环遍历
public class HashSetDemo {
public static void main(String[] args) {
//创建集合对象
HashSet<String> set = new HashSet<String>();
//添加元素
set.add("hello");
set.add("world");
set.add("java");
//不包含重复元素的集合
set.add("world");
//遍历
for(String s : set) {
System.out.println(s);
}
}
}
哈希值
- 什么是哈希值？
哈希值是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。 - 如何获取哈希值？
Object类中的public int hashCode()：返回对象的哈希码值 - 哈希值的特点
同一个对象多次调用hashCode()方法返回的哈希值是相同的。
默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同。
HashSet存储相同元素解决办法
HashSet集合存储自定义类型元素,要想实现元素的唯一,要求必须重写hashCode方法和equals方法。
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 boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
public class HashSetDemo02 {
public static void main(String[] args) {
//创建HashSet集合对象
HashSet<Student> hs = new HashSet<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
Student s4 = new Student("王祖贤", 33);
//把学生添加到集合
hs.add(s1);
hs.add(s2);
hs.add(s3);
hs.add(s4);
//遍历集合(增强for)
for (Student s : hs) {
System.out.println(s.getName() + "," + s.getAge());
}
}
}
5.LinkedHashSet集合
- LinkedHashSet集合是HashSet类的子类
- 特点
LinkedHashSet是哈希表和链表实现的Set接口，具有可预测的读写顺序。
有链表来保证元素有序。
有哈希表来保证元素的唯一性。
public class Demo05 {
public static void main(String[] args) {
LinkedHashSet<String> set = new LinkedHashSet<>();
//添加元素
set.add("黄固");
set.add("欧阳锋");
set.add("段智兴");
set.add("洪七公");
set.add("段智兴");//重复的元素不能存进去
System.out.println(set);//打印集合 [黄固, 欧阳锋, 段智兴, 洪七公]
}
}
五.Map集合
1.特点
- 双列集合,一个键对应一个值
- 键不可以重复,值可以重复
import java.util.HashMap;
import java.util.Map;
public class MapDemo1 {
public static void main(String[] args) {
//创建集合对象
Map<String,String> map = new HashMap<String,String>();
//V put(K key, V value) 将指定的值与该映射中的指定键相关联
map.put("itheima001","林青霞");
map.put("itheima002","张曼玉");
map.put("itheima003","王祖贤");
map.put("itheima003","柳岩");
//输出集合对象
System.out.println(map);
}
}
//{itheima003=柳岩, itheima001=林青霞, itheima002=张曼玉}
interface Map<K,V> K：键的类型；V：值的类型
1、Map和Collection没有继承关系。
2、Map集合以key和value的方式存储数据：
键值对key和value都是引用数据类型。
key和value都是存储对象的内存地址。
key起到主导的地位，value是key的一个附属品。
2.Map基本功能
- V put(K key,V value) 设置键值对
- V remove(Object key) 删除元素
- void clear() 清空集合
- boolean containsKey(Object key) 判断键是否存在，存在则返回true
- boolean containsValue(Object value) 判断值是否存在，存在则返回true
- boolean isEmpty() 判断集合是否为空
- int size() 获取集合元素个数
import java.util.HashMap;
import java.util.Map;
public class MapDemo2 {
public static void main(String[] args) {
//创建集合对象
Map<String,String> map = new HashMap<String,String>();
//V put(K key,V value)：添加元素
map.put("张无忌","赵敏");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
//V remove(Object key)：根据键删除键值对元素
/*System.out.println(map.remove("郭靖"));
System.out.println(map.remove("郭襄"));*/
/*黄蓉
null
2
{杨过=小龙女, 张无忌=赵敏}
*/
//void clear()：移除所有的键值对元素
//map.clear();
/*
0
{}*/
//boolean containsKey(Object key)：判断集合是否包含指定的键
/*System.out.println(map.containsKey("郭靖"));
System.out.println(map.containsKey("郭襄"));*/
/*
true
false
3
{杨过=小龙女, 郭靖=黄蓉, 张无忌=赵敏}*/
//boolean isEmpty()：判断集合是否为空
//System.out.println(map.isEmpty());//flase
//int size()：集合的长度，也就是集合中键值对的个数
System.out.println(map.size());
//输出集合对象
System.out.println(map);
}
}
3. Map集合的获取功能
- V get(Object key) 根据键获取值
- Set keySet() 获取所有键的集合
- Collection values() 获取所有值的集合
- Set<Map.Entry<K,V>> entrySet() 获取所有键值对对象的集合
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
import java.util.Collection;
public class MapDemo3 {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("张无忌", "赵敏");
map.put("郭靖", "黄蓉");
map.put("杨过", "小龙女");
//V get(Object key):根据键获取值
System.out.println(map.get("张无忌"));//赵敏
System.out.println(map.get("张三丰"));//null
//Set<K> keySet():获取所有键的集合
Set<String> keySet = map.keySet();
/*杨过
郭靖
张无忌*/
for(String key : keySet) {
System.out.println(key);
}
//Collection<V> values():获取所有值的集合
Collection<String> values = map.values();
for(String value : values) {
System.out.println(value);
}
/*小龙女
黄蓉
赵敏*/
}
}
4.Map集合的遍历
1.keySet()方法
步骤分析
- 获取所有键的集合。用keySet()方法实现
- 遍历键的集合，获取到每一个键。用增强for实现
- 根据键去找值。用get(Object key)方法实现
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
public class MapDemo01 {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("张无忌", "赵敏");
map.put("郭靖", "黄蓉");
map.put("杨过", "小龙女");
//获取所有键的集合。用keySet()方法实现
Set<String> keySet = map.keySet();
//遍历键的集合，获取到每一个键。用增强for实现
for (String key : keySet) {
//根据键去找值。用get(Object key)方法实现
String value = map.get(key);
System.out.println(key + "," + value);
}
}
}
2.entrySet()方法
步骤分析
-
获取所有键值对对象的集合
Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
-
遍历键值对对象的集合，得到每一个键值对对象
用增强for实现，得到每一个Map.Entry
-
根据键值对对象获取键和值
用getKey()得到键
用getValue()得到值
import java.util.HashMap;
import java.util.Set;
import java.util.Map;
public class MapDemo4 {
public static void main(String[] args) {
//创建集合对象
Map<String, String> map = new HashMap<String, String>();
//添加元素
map.put("张无忌", "赵敏");
map.put("郭靖", "黄蓉");
map.put("杨过", "小龙女");
//获取所有键值对对象的集合
Set<Map.Entry<String, String>> entrySet = map.entrySet();
//遍历键值对对象的集合，得到每一个键值对对象
for (Map.Entry<String, String> me : entrySet) {
//根据键值对对象获取键和值
String key = me.getKey();
String value = me.getValue();
System.out.println(key + "," + value);
}
}
}
3. forEach(BiConsumer)方法
import java.util.HashMap;
public class MapDemo5{
public static void main(String[] args){
HashMap<String, String> hm = new HashMap<String, String>();
hm.put("hm001","张三");
hm.put("hm002","李四");
hm.put("hm003","王五");
hm.forEach((String key,String value)->{System.out.println(key + "=" + value);});
}
}
4.values()方法
import java.util.HashMap;
import java.util.Map;
import java.util.Collection;
public class MapDemo7{
public static void main(String[] args){
HashMap<String, String> hm = new HashMap<String, String>();
hm.put("hm001","张三");
hm.put("hm002","李四");
hm.put("hm003","王五");
// values()获取map集合中所有的值，返回到一个Collection集合中。forEach(); 方法
Collection<String> values = hm.values();
values.forEach((String value)->{System.out.println(value);});
}
}
5.HashMap集合
特点
- HashMap底层是哈希表结构的
- 依赖hashCode方法和equals方法保证键的唯一
- 如果键要存储的是自定义对象，需要重写hashCode和equals方法
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class HashMapDemo {
public static void main(String[] args) {
//创建HashMap集合对象
HashMap<Student, String> hm = new HashMap<Student, String>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
Student s4 = new Student("王祖贤", 33);
Student s5 = new Student("王祖贤", 34);
//把学生添加到集合
hm.put(s1, "西安");
hm.put(s2, "武汉");
hm.put(s3, "郑州");
hm.put(s4, "北京");
hm.put(s5, "北京");
//遍历集合
Set<Student> keySet = hm.keySet();
for (Student key : keySet) {
String value = hm.get(key);
System.out.println(key.getName() + "," + key.getAge() + "," + value);
}
/*王祖贤,33,北京
王祖贤,34,北京
张曼玉,35,武汉
林青霞,30,西安*/
}
}
6.TreeMap集合
特点
- TreeMap底层是红黑树结构
- 依赖自然排序或者比较器排序,对键进行排序
- 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则
自然排序
import java.util.TreeMap;
public class TreeMapDemo2 {
public static void main(String[] args){
TreeMap<String, String> tm = new TreeMap<String, String>();
tm.put("tm001","张三");
tm.put("tm002","李四");
tm.put("tm003","王五");
System.out.println(tm);
/*{tm001=张三, tm002=李四, tm003=王五}*/
}
}
Comparable接口
public class Student2 implements Comparable<Student2>{
private String name;
private int age;
public Student2() {
}
public Student2(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 "Student2{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student2 o) {
//按照年龄进行排序
int result = o.getAge() - this.getAge();
//次要条件，按照姓名排序。
result = result == 0 ? o.getName().compareTo(this.getName()) : result;
return result;
}
}
import java.util.TreeMap;
public class TreeMapDemo {
public static void main(String[] args) {
// 创建TreeMap集合对象
TreeMap<Student2,String> tm = new TreeMap<>();
// 创建学生对象
Student2 s1 = new Student2("xiaohei",23);
Student2 s2 = new Student2("dapang",22);
Student2 s3 = new Student2("xiaomei",22);
// 将学生对象添加到TreeMap集合中
tm.put(s1,"江苏");
tm.put(s2,"北京");
tm.put(s3,"天津");
// 遍历TreeMap集合,打印每个学生的信息
tm.forEach(
(Student2 key, String value)->{
System.out.println(key + "---" + value);
}
);
}
}
/*Student2{name='xiaohei', age=23}---江苏
Student2{name='xiaomei', age=22}---天津
Student2{name='dapang', age=22}---北京
*/
7.Properties集合
- Properties是一个Map集合，继承Hashtable，Properties的key和value都是String类型。
- Properties被称为属性类对象。
- Properties是线程安全的。
构造方法
Properties() 创建一个Properties集合对象
成员方法
- String getProperty(String key) 通过键获取值
- void load(InputStream inStream) 从流中读取文件
- Object setProperty(String key,String value) 向集合中添加数据
- void store(OutputStream out, String comments) 将集合中的数据通过输出流写出到文件中
1375
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
