Collection 接口 集合顶层接口
--List
元素允许重复，是有序的（存储和取出顺序一致），拥有下标索引的特点
--ArrayList
底层数据结构是数组，查询快，增删慢
线程不安全的，效率高
--Vector
底层数据结构是数组，查询快，增删慢
线程是安全的，效率低 （即使是线程安全的，我们将来不会去使用，因为有更好的去替代）
用Collections中带synchronized方法将不安全的集合转成安全的集合
--LinkedList
底层数据结构是双链表，查询慢，增删快
线程是不安全的，效率高
--Set
元素唯一，无序
--HashSet
底层数据结构是哈希表，哈希表保证元素的唯一性
但是当存储的是自定义对象的时候，要重写hashCode()和equals()方法
--LinkedHashSet
底层数据结构是哈希表和链表，哈希表保证元素的唯一性，链表保证元素的有序（存储和取出顺序一致）
--TreeSet
底层数据结构是红黑树，遍历的时候中序遍历
自然排序 元素的数据类型的类要实现Comparable，重写compareTo()方法
比较器排序
自定义一个类实现Comparator接口，重写compare()方法
匿名内部类的形式进行构造方法传参，重写compare()方法
Map 接口
元素是由一个一个键值对组成，键不允许重复，值允许重复
--HashMap
底层数据结构是哈希表，保证了元素的唯一（指的是键的唯一性），元素是无序
当键是自定义类型的时候，要想保证唯一性，就必须重写hashCode()方法和equals()方法
--LinkedHashMap
底层数据结构是哈希表和链表
哈希表保证的是元素的唯一性
链表保证的是元素有序（指的是存储和取出的顺序一致）
--TreeMap
底层数据结构是红黑树
排序针对于键来说的
自然排序
比较器排序
自定义一个类实现Comparator接口，重写compare()方法
匿名内部类的形式进行构造方法传参，重写compare()方法
将来开发的时候用谁呢？
1、元素的组成是单个还是成对，如果是单个使用Collection下面的集合，如果是成对出现的，使用Map下面的集合
2、元素允许重复吗？
允许：List
不允许：Set
3、元素需要排序吗？
需要：TreeSet或者TreeMap
不需要：ArrayList等
4、将来查找的功能多吗？
多，用底层是数组的集合
5、将来增删操作多吗？
多，用底层是链表的集合
如果你什么都不知道，用ArrayList。推荐具体情况具体选择。
注意：
增强for循环只能作用于数组和Collection集合，不适用于Map集合
HashSet集合存储自定义对象并遍历。
如果对象的成员变量值相同即为同一个对象
1、创建一个学生类
2、创建HashSet集合对象
3、创建5个学生对象
4、将学生对象添加到集合中
5、遍历
Student
import java.util.Objects;
public class Student1 {
private String name;
private int age;
public Student1() {
}
public Student1(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 "Student1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student1 student1 = (Student1) o;
return age == student1.age && Objects.equals(name, student1.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}测试类
import java.util.HashSet;
public class SetClass1 {
public static void main(String[] args) {
//创建对象
HashSet<Student1> set = new HashSet<>();
//创建5个学生对象
Student1 s1 = new Student1("明", 18);
Student1 s2 = new Student1("王", 19);
Student1 s3 = new Student1("周", 17);
Student1 s4 = new Student1("张", 20);
Student1 s5 = new Student1("明", 18);
//将学生对象添加到集合中
set.add(s1);
set.add(s2);
set.add(s3);
set.add(s4);
set.add(s5);
//遍历
for (Student1 s:set){
System.out.println(s);
}
}
}
结果：
Student1{name='周', age=17}
Student1{name='王', age=19}
Student1{name='明', age=18}
Student1{name='张', age=20}TreeSet集合存储自定义对象并遍历
如果对象的成员变量值相同即为同一个对象
按照年龄进行从大到小进行排序
Student类
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 "Student1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student2 o) {
//按年龄大小排序
int i=o.age-this.age;
//年龄一样姓名不一定一样
int i2=i==0?o.name.compareTo(this.name):i;
return i2;
}
}
测试类
mport java.util.Comparator;
import java.util.TreeSet;
public class SetTest2 {
public static void main(String[] args) {
//无参构造走自然排序
// TreeSet<Student2> set1 = new TreeSet<>();
//有参构造走比价器排序
TreeSet<Student2> set1= new TreeSet<Student2>(new Comparator<Student2>() {
@Override
public int compare(Student2 o1, Student2 o2) {
//按年龄大小排序
int i=o2.getAge()-o1.getAge();
//年龄一样姓名不一定一样
int i2=i==0?o1.getName().compareTo(o2.getName()):i;
return i2;
}
});
//创建学生对象
Student2 s1 = new Student2("刘备", 19);
Student2 s2 = new Student2("曹操", 19);
Student2 s3 = new Student2("孙权", 7);
Student2 s4 = new Student2("诸葛亮", 11);
Student2 s5 = new Student2("司马懿", 19);
Student2 s6 = new Student2("刘备", 20);
//将学生对象添加到集合中
set1.add(s1);
set1.add(s2);
set1.add(s3);
set1.add(s4);
set1.add(s5);
set1.add(s6);
//遍历
for (Student2 s:set1){
System.out.println(s);
}
}
}
结果：
Student1{name='刘备', age=20}
Student1{name='刘备', age=19}
Student1{name='司马懿', age=19}
Student1{name='曹操', age=19}
Student1{name='诸葛亮', age=11}
Student1{name='孙权', age=7}
键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低输出到控制台
1、创建学生类
2、创建集合对象TreeSet
3、创建学生对象
4、将学生对象添加到集合中
5、遍历
Student类
public class Student3 {
private String name;
private int age;
private int math;
private int english;
private int chinese;
public Student3() {
}
public Student3(String name, int age, int math, int english, int chinese) {
this.name = name;
this.age = age;
this.math = math;
this.english = english;
this.chinese = chinese;
}
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 int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getEnglish() {
return english;
}
public void setEnglish(int english) {
this.english = english;
}
public int getChinese() {
return chinese;
}
public void setChinese(int chinese) {
this.chinese = chinese;
}
public int geSum(){
return chinese+math+chinese;
}
@Override
public String toString() {
return "Student3{" +
"name='" + name + '\'' +
", age=" + age +
", math=" + math +
", english=" + english +
", chinese=" + chinese +
'}';
}
}
测试类
import java.util.Comparator;
import java.util.TreeSet;
import java.util.Scanner;
public class SetTest3 {
public static void main(String[] args) {
//比较器排序
TreeSet<Student3> set2 = new TreeSet<>(new Comparator<Student3>() {
@Override
public int compare(Student3 o1, Student3 o2) {
// return 0;
//按总分从高到低输出
int i=o2.geSum()-o1.geSum();
//总分一样语文成绩不一样
int i2=i==0?o2.getChinese()-o1.getChinese():i;
//语文成绩一样，数学成绩不一定一样
int i3 = i2 == 0 ? o2.getMath() - o1.getMath() : i2;
//各科成绩一样姓名不一定一样
int i4=i3==0?o2.getName().compareTo(o1.getName()):i3;
return i4;
}
});
Scanner sc = new Scanner(System.in);
//使用创建学生对象并添加到集合中
for (int i=0;i<=5;i++){
System.out.println("请输入第" + i + "个学生的姓名：");
String name = sc.next();
System.out.println("请输入" + name + "学生的语文成绩：");
int chinese = sc.nextInt();
System.out.println("请输入" + name + "学生的数学成绩成绩：");
int math = sc.nextInt();
System.out.println("请输入" + name + "学生的英语成绩：");
int english = sc.nextInt();
//创建学生对象
Student3 student3 = new Student3();
student3.setName(name);
student3.setChinese(chinese);
student3.setMath(math);
student3.setEnglish(english);
//将学生对象添加到学生集合中去
set2.add(student3);
}
System.out.println("=============================================================");
System.out.println("学生的信息如下：");
System.out.println("姓名\t语文成绩\t数学成绩\t英语成绩\t总成绩");
//遍历学生信息
for (Student3 student3:set2){
System.out.println(student3.getName() + "\t" + student3.getChinese() + "\t" + student3.getMath() + "\t"
+ student3.getEnglish() + "\t" + student3.geSum());
}
}
}
结果：
请输入第0个学生的姓名：
wj
请输入wj学生的语文成绩：
45
请输入wj学生的数学成绩成绩：
45
请输入wj学生的英语成绩：
587
请输入第1个学生的姓名：
ad
请输入ad学生的语文成绩：
45
请输入ad学生的数学成绩成绩：
49
请输入ad学生的英语成绩：
89
请输入第2个学生的姓名：
dji
请输入dji学生的语文成绩：
65
请输入dji学生的数学成绩成绩：
89
请输入dji学生的英语成绩：
78
请输入第3个学生的姓名：
hdu
请输入hdu学生的语文成绩：
48
请输入hdu学生的数学成绩成绩：
35
请输入hdu学生的英语成绩：
89
请输入第4个学生的姓名：
hdu
请输入hdu学生的语文成绩：
12
请输入hdu学生的数学成绩成绩：
78
请输入hdu学生的英语成绩：
64
请输入第5个学生的姓名：
dji
请输入dji学生的语文成绩：
13
请输入dji学生的数学成绩成绩：
65
请输入dji学生的英语成绩：
98
=============================================================
学生的信息如下：
姓名 语文成绩 数学成绩 英语成绩 总成绩
dji 65 89 78 219
ad 45 49 89 139
wj 45 45 587 135
hdu 48 35 89 131
hdu 12 78 64 102
dji 13 65 98 91
Map接口的概述
将键映射到值的对象。
Map不能包含重复的键;
每个键可以映射到最多一个值。
举例：
键值对
1001 王
1002 周
1001 周（不允许）
Map集合中，K的值不能重复
Map接口与Collection接口有什么区别？
1、Map接口与Collection接口是平级关机，不存在继承关系，都是属于util包下面的
2、Map集合中的元素都是成对出现的，Map集合中的键是唯一的，值是可以重复的 又称之为：夫妻对
3、Collection集合中的元素都是单独出现的，Collection接口下面有个子接口Set，它的元素也是唯一的
List中的元素也是单独出现，可以重复，像这样单独出现的元素，称之为：光棍
Map接口中的方法：
1、添加功能：
V put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操作）。
举例：map.put(1001,"王");
2、删除功能：
void clear() 从该Map中删除所有的映射（可选操作）。
V remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射。
3、判断功能：
boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。
boolean isEmpty() 如果此地图不包含键值映射，则返回 true 。
4、获取功能：
V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
Set keySet() 返回此Map中包含的键的Set视图。
Collection values() 返回此Map中包含的值的Collection视图
Set> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成
5、长度功能：
int size() 返回此Map中键值映射的数量。
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
//创建Map集合对象
//由于Map是一个接口，所以接口不能直接实例化，要使用一个具体的子类进行实例化
//这里借助HashMap
Map<String, String> map = new HashMap<>();
//添加元素
//V put(K key, V value) 将指定的值与该映射中的指定键相关联（可选操作）。
//这里的返回值是将来再次插入同一个键的时候，被覆盖的那个值
map.put("黄晓明","杨颖");
map.put("邓超","孙俪");
map.put("小虎","冯提莫");
map.put("小虎","IU");
//删除功能
//void clear() 从该Map中删除所有的映射（可选操作）
// map.clear();
// V remove(Object key) 如果存在（从可选的操作），从该Map中删除一个键的映射。
//返回对应删除的值
// System.out.println(map.remove("小虎"));
System.out.println("==========================================");
//boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
System.out.println(map.containsKey("小虎"));
//boolean containsValue(Object value) 如果此地图将一个或多个键映射到指定的值，则返回 true 。
System.out.println(map.containsValue("IU"));
System.out.println(map.isEmpty());
System.out.println(map);
}
}
结果：
true
true
false
{邓超=孙俪, 小虎=IU, 黄晓明=杨颖}Map集合的获取功能：
V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
Set keySet() 返回此Map中包含的键的Set视图。
Collection values() 返回此Map中包含的值的Collection视图
import java.util.Collection;
import java.util.HashMap;
import java.util.Set;
public class MapDemo2 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
//添加元素
map.put("黄晓明", "杨颖");
map.put("邓超", "孙俪");
map.put("小虎", "冯提莫");
map.put("张杰", "谢娜");
//V get(Object key) 返回到指定键所映射的值，或 null如果此映射包含该键的映射。
//根据key找值
//如果map中不包含此key，返回null
System.out.println(map.get("小虎"));
System.out.println(map.get("小明"));
System.out.println("===============================================");
//Set<K> keySet() 返回此Map中包含的键的Set视图。
Set<String> set = map.keySet();
for (String s:set) {
String value = map.get(s);
System.out.println(s + ":" + value);
}
//Collection<V> values() 返回此Map中包含的值的Collection视图
Collection<String> values = map.values();
for (String s1:values){
System.out.println(s1);
}
}
}
结果：
冯提莫
null
===============================================
邓超:孙俪
小虎:冯提莫
张杰:谢娜
黄晓明:杨颖
孙俪
冯提莫
谢娜
杨颖集合遍历的方式一：根据键找值
1、通过调用keySet()方法获取Map集合中所有的key
2、结合get(key)这个方法，可以获取到每一个key对应的value
3、输出
mport java.util.HashMap;
import java.util.Set;
public class MapDemo3{
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
//添加元素
map.put("霞", "洛");
map.put("蛮王", "寒冰");
map.put("卢锡安", "塞纳");
map.put("盖伦", "卡特");
//通过调用keySet()方法获取Map集合中所有的key
Set<String> strings = map.keySet();
for (String s:strings){
String s1 = map.get(s);
System.out.println(s+":"+s1);
}
}
}
结果：
卢锡安:塞纳
蛮王:寒冰
霞:洛
盖伦:卡特Map集合遍历的第二种方式：
一次先把所有的键值对获取到，然后在依次获取每一个键值对的key和value
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo4 {
public static void main(String[] args) {
HashMap<String, String> map = new HashMap<>();
//添加元素
map.put("王子1", "白雪公主");
map.put("王子2", "灰姑凉");
map.put("王子3", "美人鱼");
//遍历：一次先把所有的键值对获取到
//Set<Map.Entry<K,V>> entrySet() 获取Map中所有元素，元素的类组成是由一个键和一个值组成
Set<Map.Entry<String, String>> set = map.entrySet();
for (Map.Entry<String, String> s:set){
String key= s.getKey();
String value = s.getValue();
System.out.println(key+":"+value);
}
}
}
结果：
王子1:白雪公主
王子2:灰姑凉
王子3:美人鱼HashMap
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo5 {
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
//添加对象
map.put(1001, "明");
map.put(1002, "王");
map.put(1003, "周");
map.put(1003, "张");
//遍历集合
System.out.println("===========方式1：根据键找值===================");
//获取到所有的key
Set<Integer> integers = map.keySet();
for (Integer i:integers){
String s = map.get(i);
System.out.println(i+":"+s);
}
System.out.println("==========方式2：根据键值对找键和值===============");
Set<Map.Entry<Integer, String>> entries = map.entrySet();
for (Map.Entry<Integer, String> s:entries){
Integer key = s.getKey();
String value = s.getValue();
System.out.println(key+":"+value);
}
}
}
结果：
===========方式1：根据键找值===================
1001:明
1002:王
1003:张
==========方式2：根据键值对找键和值===============
1001:明
1002:王
1003:张HashMap
Student类
public class Student4 {
private String name;
private int age;
public Student4() {
}
public Student4(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 "Student1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
测试类
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo6 {
public static void main(String[] args) {
HashMap<String,Student4> map = new HashMap<>();
//创建学生对象
Student4 s1 = new Student4("明", 18);
Student4 s2 = new Student4("王", 17);
Student4 s3 = new Student4("周", 19);
Student4 s4 = new Student4("张", 19);
//向集合里添加键值对
map.put("帅气男孩", s1);
map.put("亿表人财", s2);
map.put("油腻大叔", s3);
map.put("忧郁男孩", s4);
Set<Map.Entry<String, Student4>> entries = map.entrySet();
for (Map.Entry<String, Student4> s:entries){
String key = s.getKey();
Student4 value = s.getValue();
System.out.println(key+":"+value);
}
}
}
结果：
帅气男孩:Student1{name='明', age=18}
油腻大叔:Student1{name='周', age=19}
亿表人财:Student1{name='王', age=17}
忧郁男孩:Student1{name='张', age=19}
HashMap
如果key是自己自定义的一个对象，该类需要重写hashCode()方法和equals()方法
因为put方法的底层，添加元素的标准就是根据hashCode()方法和equals()的值来判断元素是否重复
Student类
import java.util.Objects;
public class Student5 {
private String name;
private int age;
public Student5() {
}
public Student5(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 "Student1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student5 student5 = (Student5) o;
return age == student5.age && Objects.equals(name, student5.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
测试类
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo7 {
public static void main(String[] args) {
HashMap<Student5, String> map = new HashMap<>();
//添加对象
Student5 s1 = new Student5("王昭君", 17);
Student5 s2 = new Student5("貂蝉", 16);
Student5 s3 = new Student5("杨玉环", 18);
Student5 s4 = new Student5("西施", 19);
Student5 s5 = new Student5("王昭君", 17);
//将元素添加到集合里去
map.put(s1,"54545");
map.put(s2,"4652");
map.put(s3,"45774");
map.put(s4,"254154");
map.put(s5,"451465");
//遍历
Set<Map.Entry<Student5, String>> entries = map.entrySet();
for (Map.Entry<Student5, String> s:entries){
Student5 key = s.getKey();
String value = s.getValue();
System.out.println(key+":"+value);
}
}
}
结果：
Student1{name='杨玉环', age=18}:45774
Student1{name='貂蝉', age=16}:4652
Student1{name='王昭君', age=17}:451465
Student1{name='西施', age=19}:254154LinkedHashMap:
class LinkedHashMap extends HashMap implements Map{}
哈希表和链表实现的Map接口，具有可预测的迭代次序。
哈希保证的是元素的唯一，保证key是唯一
链表保证是有序的（存储和取出的顺序一致）
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
public class LinkedHashMapDemo {
public static void main(String[] args) {
LinkedHashMap<String, String> map = new LinkedHashMap<>();
//添加元素
map.put("1234", "hello");
map.put("4567", "world");
map.put("3456", "java");
map.put("7890", "hadoop");
map.put("1234", "hive");
map.put("5689", "hive");
//遍历
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> keyValue : entries) {
String key = keyValue.getKey();
String value = keyValue.getValue();
System.out.println(key + ":" + value);
}
}
}
结果：
1234:hive
4567:world
3456:java
7890:hadoop
5689:hive
TreeMap:键是基于红黑树结构存储的
键：String
值：String
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo1 {
public static void main(String[] args) {
TreeMap<String, String> map = new TreeMap<>();
//创建元素
map.put("hello", "你好");
map.put("world", "世界");
map.put("java", "面向对象的编程语言");
map.put("mysql", "结构化数据库");
//遍历
Set<Map.Entry<String, String>> entries = map.entrySet();
for (Map.Entry<String, String> s:entries){
String value = s.getValue();
String key = s.getKey();
System.out.println(key+":"+value);
}
}
}
结果
hello:你好
java:面向对象的编程语言
mysql:结构化数据库
world:世界TreeMap
键：Student 键的存储是红黑树结构存储，可以保证键的排序和唯一
值：String
Student类
public class Student6 {
private String name;
private int age;
public Student6() {
}
public Student6(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 "Student1{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
import java.util.*;
public class TreeMapDemo2 {
public static void main(String[] args) {
//推荐使用比较器排序，并且用匿名内部类实现
TreeMap<Student6,String> map= new TreeMap<>(new Comparator<Student6>() {
@Override
public int compare(Student6 o1, Student6 o2) {
// return 0;
//判断年龄
int i=o1.getAge()-o2.getAge();
//年龄一样判断姓名
int i2=i==0?o1.getName().compareTo(o2.getName()):i;
return i2;
}
});
//2、创建学生对象
Student6 s1 = new Student6("明", 18);
Student6 s2 = new Student6("王", 19);
Student6 s3 = new Student6("周", 20);
Student6 s4 = new Student6("张", 17);
Student6 s5 = new Student6("明", 18);
//3、向集合中添加元素
map.put(s1, "男枪");
map.put(s2, "女警");
map.put(s3, "卡特");
map.put(s4, "霞");
map.put(s5, "男枪");
//遍历
Set<Map.Entry<Student6, String>> entries = map.entrySet();
for (Map.Entry<Student6, String> s:entries){
Student6 key = s.getKey();
String value = s.getValue();
System.out.println(key+":"+value);
}
}
}
结果：
Student1{name='张保桂', age=17}:霞
Student1{name='明旺', age=18}:男枪
Student1{name='王宇', age=19}:女警
Student1{name='周家祥', age=20}:卡特"aababcabcdabcde",获取字符串中每一个字母出现的次数要求结果:a(5)b(4)c(3)d(2)e(1)
分析：
1、定义一个字符串（后期可用键盘录入改进）
2、定义一个TreeMap对象存储数据
键：Character
值：Integer
3、将字符串转成字符数组
4、遍历字符数组，得到每一个字符
5、拿着这个字符作为键去map集合中去找，看返回值
如果返回值是null,表示集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
如果返回值不是null,说明集合中已经存在这个字符作为键，value值+1，然后重新放入到集合中
6、定义一个StringBuffer作为拼接
7、遍历集合得到键和值，按照对应的输出格式进行拼接
8、把StringBuffer输出
输入：aababcabcdabcde
输出：a(5)b(4)c(3)d(2)e(1)
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class TreeMapDemo3 {
public static void main(String[] args) {
//创建键盘录入对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您要统计的字符串：");
String s = scanner.next();
//定义一个TreeMap对象存储数据
TreeMap<Character, Integer> map = new TreeMap<>();
//将字符串转成字符数组
char[] chars = s.toCharArray();
//遍历字符数组，得到每一个字符 增强for循环遍历
for (Character c:chars){
Integer integer = map.get(c);
//如果返回值是null,表示集合中没有该字符作为键，就把当前这个字符设置为键，value设置为1
if (integer==null){
map.put(c,1);
}else {
integer++;
map.put(c,integer);
}
}
//定义一个StringBuffer作为拼接
StringBuffer stringBuffer = new StringBuffer();
//遍历集合得到键和值，按照对应的输出格式进行拼接
Set<Map.Entry<Character, Integer>> entries = map.entrySet();
for (Map.Entry<Character, Integer> keyValue : entries) {
Character ch = keyValue.getKey();
Integer number = keyValue.getValue();
stringBuffer.append(ch).append("(").append(number).append(")");
}
//将StringBuffer转成字符串
String s1 = stringBuffer.toString();
System.out.println(s1);
}
}
结果：
请输入您要统计的字符串：
;fl[pkfsafjkoapkdAFP[LA
;(1)A(2)F(1)L(1)P(1)[(2)a(2)d(1)f(3)j(1)k(3)l(1)o(1)p(2)s(1)
ArrayList嵌套HashMap
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class ArrayListAndHashMap {
public static void main(String[] args) {
//定义一个ArrayList对象
ArrayList<HashMap<String,String>> list = new ArrayList<>();
//创建2个HashMap对象
HashMap<String, String> map1 = new HashMap<>();
map1.put("霞", "洛");
map1.put("卢锡安", "塞纳");
map1.put("蛮王", "寒冰");
map1.put("盖伦", "卡特");
HashMap<String, String> map2 = new HashMap<>();
map2.put("邓超", "孙俪");
map2.put("张杰", "谢娜");
map2.put("小虎", "冯提莫");
list.add(map1);
list.add(map2);
for (HashMap<String,String> s:list){
Set<Map.Entry<String, String>> entries = s.entrySet();
for (Map.Entry<String, String> i:entries){
String value = i.getValue();
String key = i.getKey();
System.out.println(key+":"+value);
}
}
}
}
结果：
卢锡安:塞纳
蛮王:寒冰
霞:洛
盖伦:卡特
邓超:孙俪
小虎:冯提莫
张杰:谢娜lue); } } } } 结果： 卢锡安:塞纳 蛮王:寒冰 霞:洛 盖伦:卡特 邓超:孙俪 小虎:冯提莫 张杰:谢娜
面试题：HashMap和Hashtable的区别
1、HashMap与Hashtable它们存储的元素都是一个一个的键值对
2、HashMap中的key和value允许为null值，而Hashtable不允许
3、Hashtable是线程安全的，而HashMap是线程不安全的
import java.util.HashMap;
import java.util.Hashtable;
public class HashTableAndHashMap {
public static void main(String[] args) {
HashMap<String, String> map1 = new HashMap<>();
map1.put(null,"123");
map1.put("111",null);
map1.put(null,null);
System.out.println(map1);
Hashtable<String, String> map2 = new Hashtable<>();
// map2.put(null,"123"); //Hashtable元素中的key不允许为null
// map2.put("111",null); //Hashtable元素中的value不允许为null
// map2.put(null,null);
map2.put("sd","da");
System.out.println(map2);
}
}
结果：
{null=null, 111=null}
{sd=da}Collections工具类的概述：
针对集合操作的工具类
Collections与Collection的区别：
1、Collection是单列集合的顶层接口，有两大子接口List/Set
2、Collections是一个针对于集合操作的工具类，可以对集合进行排序，还有查找（二分查找）
public static void sort(List list)
public static int binarySearch(List list,T key)
public static T max(Collection coll)
public static void reverse(List list)
public static void shuffle(List list)
static List synchronizedList(List list) 返回由指定列表支持的同步（线程安全）列表。
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class CollectionsDemo1 {
public static void main(String[] args) {
ArrayList<Integer> list= new ArrayList<>();
//将ArrayList转换成线程安全的集合，返回的集合和原本的是一个存储空间
List<Integer> list1 = Collections.synchronizedList(list);
//添加元素
list1.add(10);
list1.add(30);
list1.add(20);
list1.add(70);
list1.add(40);
list1.add(50);
System.out.println(list);
System.out.println(list1);
System.out.println("========================================");
System.out.println("排序前的集合："+list);
//public static <T> void sort(List<T> list)
Collections.sort(list);
System.out.println("排序后的集合："+list);
System.out.println("========================================");
//public static <T> binarySearch(List<?> list,T key):二分查找前提是有序
//二分查找，如果元素存在，返回该元素对应索引
System.out.println(Collections.binarySearch(list,70));
System.out.println(Collections.binarySearch(list,700));
//public static <T> T max(Collection<?> coll):查找最大值
System.out.println(Collections.max(list));
//public static void reverse(List<?> list) 反转
System.out.println("========================================");
System.out.println("反转之前");
System.out.println(list);
Collections.reverse(list);
System.out.println("反转之后");
System.out.println(list);
System.out.println("========================================");
//public static void shuffle(List<?> list):随机置换
Collections.shuffle(list);
System.out.println(list);
}
}
结果：
[10, 30, 20, 70, 40, 50]
[10, 30, 20, 70, 40, 50]
========================================
排序前的集合：[10, 30, 20, 70, 40, 50]
排序后的集合：[10, 20, 30, 40, 50, 70]
========================================
5
-7
70
========================================
反转之前
[10, 20, 30, 40, 50, 70]
反转之后
[70, 50, 40, 30, 20, 10]
========================================
[70, 20, 40, 50, 30, 10]//这一项是随机的
8957
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
