Java数据结构及工具类
`1 数据结构
常见的数据结构 : 栈堆 , 队列, 数组, 链表和红黑树
栈
栈 : 它是运算受限的线性表, 其限制是仅允许在标的一端进行插入和删除操作, 不允许在其他任何位置进行添加, 查找, 删除等操作
- 先进后出（即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素）
- 栈的入口, 出口都是栈的顶端位置
压栈 : 就是存元素。即，把元素存储到栈的顶端位置，栈中已有元素依次向栈底方向移动一个位置
弹栈 : 就是取元素。即，把栈的顶端位置元素取出，栈中已有元素依次向栈顶方向移动一个位置。
队列
队列 : 它也是运算受限的线性表, 其限制是仅允许在表的一端进行插入，而在表的另一端进行删除。
- 先进先出 （即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素）
数组
数组 : 它是有序的元素序列, 数组是在内存中开辟一段连续的空间, 并在此空间存放元素; 每个元素都有对应的索引
特点 : 查找快, 通过索引, 可以快速访问指定位置的元素; 但是插入和删除操作费时
- 指定索引位置增加元素 : 需要创建一个新数组，将指定新元素存储在指定索引位置，再把原数组元素根据索引，复制到新数组对应索引的位置
- 指定索引位置删除元素 : 需要创建一个新数组，把原数组元素根据索引，复制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中
链表
链表 : linked list 是由一系列节点node(链表中每一个元素称为节点)组成, 节点可以在运行时动态生成, 每个节点包括两个部分: 一个是存储数据元素的数据域, 另外一个是存储指向下一个节点地址的指针域, 常见的链表还有单向链表和双向链表
特点 : 多个节点之间, 通过地址链接; 例如，多个人手拉手，每个人使用自己的右手拉住下个人的左手，依次类推，这样多个人就连在一起了
存储元素和取出元素的顺序有可能不一样
- 查找元素慢 : 想查找某个元素, 需要通过链接的节点, 依次向后查找指定元素
- 增删元素快 : 只需要修改链接下个元素的地址即可
红黑树
二叉树 : binary tree, 是每个节点不超过 2 的有序树; 就是一种类似于我们生活中树的结构, 只不过每个节点上都最多只能有两个子节点; 二叉树是每个节点最多有两个子树的树结构; 顶上的叫根节点, 两把被称为" 左子树"和" 右子树"
红黑树 : 本身就是一颗二叉查找数 , 将节点插入后, 该数仍然是一颗二叉查找数, 也就意味着, 树的键值仍然是有序的
红黑树的约束 :
- 节点可以是红色或者黑色的
- 根节点是黑色的
- 叶子节点(特指空节点)是黑色的
- 每个红色节点的子节点是黑色的
- 任何一个节点到每一个叶子节点的所有路径上黑色节点数相同
特点 : 速度特别快, 趋近平衡树, 查找叶子元素最少和最多次数不多于二倍
2 List接口
以下 接口 都是 Collection接口中的子类
java.util.List 接口继承自Collection 接口, 是单列集合的一个重要分支 , 习惯性地会将实现了List接口的对象称为List集合, 在List集合中允许出现重复的元素, 所有的元素是以一种线性方式进行存储的, 在程序中可以通过索引来访问集合中的指定元素; List集合还有一个特点就是元素有序, 即元素的存入顺序和取出顺序一致
特点:
- 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的
- 它是一个带有索引的集合, 通过索引就可以精确的操作集合中的元素(与数组的索引是一个道理)
- 集合中可以有重复的元素, 铜鼓哦元素的equals方法,来比较是否为重复的元素
List接口中常用方法
List 作为Collection集合 的子接口, 不但继承了 Collection 接口中的全部方法, 而且还增加了一些根据元素索引来操作集合的特有方法
public void add(int index,E element) : 将指定的元素, 添加到该集合中的指定位置上
public E get(int index) : 返回集合中指定位置的元素
public E remove(int index) : 移除列表中指定位置的元素 , 返回的是被移除的元素
public E set(int index , E element) : 用指定元素替换集合中指定位置的元素, 返回值是更新前的元素
import java.util.ArrayList;
import java.util.List;
public class Demo01List {
public static void main(String[] args) {
// 创建一个List集合对象, 多态
List<String> list = new ArrayList<>();
// 不加索引, 默认在list尾端加入
list.add("a");
list.add("b");
list.add(1,"itcast");
list.add("d");
list.add("e");
System.out.println(list);
// 获取指定索引的元素
System.out.println(list.get(1));
// 移除指定索引的元素
System.out.println(list.remove(2));
// 更新指定索引的元素
list.set(1,"HelloWorld");
System.out.println(list);
}
}
3 List的子类
ArrayList集合
java.util.ArrayList 集合数据存储的结构是数组结构; 元素增删慢, 查找快, 由于日常开发中使用最多的功能为查询数据, 遍历数据; 所以ArrayList 是常用的集合
LinkedList集合
java.util.LinkedList 集合数据存储的结构是链表结构, 方便元素添加, 删除的集合
LinkedList 是一个双向链表, 那么双向链表是什么样子的呢?
实际开发对一个集合元素的添加与删除经常涉及到首尾操作, LinkedList提供大量的首尾操作的方法
public void addFirst(E e): 将指定元素插入到此列表的开头public void addLast(E e): 将指定元素插入到此列表的结尾public void getFirst(): 获取此列表的第一个元素public void getLast(): 获取此列表的最后一个元素public void removeFirst(): 移除并返回此列表的第一个元素public void removeLast(): 移除并返回此列表的最后一个元素public E pop(): 从此列表中所表示的栈出弹出栈顶的一个元素public E push(): 将元素推入到此列表所表示的栈public boolean isEmpty(): 如果列表不包含元素, 则返回true
LinkedList 是 List的子类, List中的方法LinkedList都是可以使用的
public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
//添加元素
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
System.out.println(link);
// 获取元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
// 删除元素
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
System.out.println(link);
while (!link.isEmpty()) { //判断集合是否为空
System.out.println(link.pop()); //弹出集合中的栈顶元素
}
System.out.println(link);
} public static void main(String[] args) {
LinkedList<String> link = new LinkedList<String>();
//添加元素
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
link.addFirst("abc4");
System.out.println(link);
// 获取元素
System.out.println(link.getFirst());
System.out.println(link.getLast());
// 删除元素
System.out.println(link.removeFirst());
System.out.println(link.removeLast());
System.out.println(link);
while (!link.isEmpty()) { //判断集合是否为空
System.out.println(link.pop()); //弹出集合中的栈顶元素
}
System.out.println(link);
}
4 Set接口
java.util.Set 接口和 javautil.List 接口一样, 同样继承自 Collection接口, 它与Cllevtion接口中的方法基本一致, 并没有对Collection接口进行功能上的扩充, 只是比 Collection 接口国家严格了, 与List 接口的不同是, Set 接口中元素无序, 并且都会以某种规则保证存入的元素不会出现重复
Set 集合有多个子类, 这里介绍java.util.HashSet, java.util.LinkedHashSer
Set集合取出元素的方式可以采用 : 迭代器, 增强for
HashSet集合
java.util.HashSet是Set接口的一个实现类，它所存储的元素是不可重复的，并且元素都是无序的(即存取顺序不一致)。java.util.HashSet底层的实现其实是一个java.util.HashMap , 查询的速度非常快
HashSet 是根据对象的哈希值来确定元素在集合中存储的位置, 因此具有良好的存取和查找性能, 保证元素唯一性的方式依赖于 : hashCode 与 equals 方法
HashSet集合存储数据的结构(哈希表)
在JDK1.8之前, 哈希表底层此案有数组+链表实现, 即使用链表处理冲突, 同一hash值的链表都存储在一个链表里; 但是当位于一个桶中的元素较多, 即has值相等的元素较多时, 通过key值一次查找的效率降低; 在JDK1.8中, 哈希表采用数组+链表+红黑树实现, 当链表长度超过阈值( 8 )时,将链表转换为红黑树
总而言之, JDK1.8引入红黑树大程度优化了HashMap的性能, 那么对于我们来讲保证HashSet 集合元素的唯一, 其实就是根据对象的hashCode和equals方法来决定的, 如果我们往集合中存放自定义的对象, 那么保证其唯一, 就必须复写hashCode和equals方法建立属于当前对象的比较方式
HashSet存储自定义类型元素
给HashSet中存放自定义类型元素时, 需要重写对象的hashCode 和 equals方法, 建立自己的比较方式, 才能保证HashSet集合中的对象唯一
set集合不允许重复元素的原理
先调用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;
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class HashSetDemo2 {
public static void main(String[] args) {
//创建集合对象 该集合中存储 Student类型对象
HashSet<Student> stuSet = new HashSet<Student>();
//存储
Student stu = new Student("于谦", 43);
stuSet.add(stu);
stuSet.add(new Student("郭德纲", 44));
stuSet.add(new Student("于谦", 43));
stuSet.add(new Student("郭麒麟", 23));
stuSet.add(stu);
for (Student stu2 : stuSet) {
System.out.println(stu2);
}
}
}
执行结果：
Student [name=郭德纲, age=44]
Student [name=于谦, age=43]
Student [name=郭麒麟, age=23]
LinkedHashSet
HashSet 保证元素唯一, 可是元素存放进去是没有顺序的, 我们要保证有序, 怎么办?
在HashSet 下有一个子类java.util. LinkedHashSet , 它是链表和哈希表组合的一个数据存储结构
public class LinkedHashSetDemo {
public static void main(String[] args) {
Set<String> set = new LinkedHashSet<String>();
set.add("bbb");
set.add("aaa");
set.add("abc");
set.add("bbc");
Iterator<String> it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
}
}
}
结果：
bbb
aaa
abc
bbc
// 与添加的顺序相同
可变参数
我们定义一个方法需要接受多个参数, 并且多个参数类型一致,通常的写法是
修饰符 返回值类型 方法名(参数类型[] 形参名)
其实完全等价于
修饰符 返回值类型 方法名(参数类型... 形参名)
前者在调用时必须传递数组, 后缀直接传递数据; JDK1.5以后 , 出现了 … 用在参数之上,称之为可变参数;
不用创建数组, 直接将数组中的元素作为实际参数进行传递
其实编译成的class文件, 还是将这些元素先封装到一个数组中, 在进行传递; 这些动作都在编译 .class文件时, 自动完成了
public class ChangeArgs{
public static void main(String[] args){
int[] arr = {1,464,35,429};
int sum = getSum(arr);
System.out.println(sum)
int sum = getSum(1,5,3,8,2,45);
System.out.println(sum)
/* 自动完成的
完成数组 所有元素求和的 原始写法
public static void getSum(init[] arr){
int sum = 0;
for(int a : arr){
sum += a;
}
return sum;
}
*/
// 可变参数写法
public static int getSum(int... arr){
int sum =0;
for(int a:arr){
sum += a;
}
return sum;
}
}
}
注意 : 这个方法如果拥有多个参数, 参数中包含可变参数, 可变参数一定要在参数列表的末尾位置
5 Collections 类
注意是 Collcetions, 后面有 s ,它是一个集合工具类, 在java.util.Collections, 部分方法如下
public static: 往集合中添加一些元素boolean addAll(Collection c,T....elements) public static void shuffle(List list): 打乱集合顺序public static void sort(List: 将集合中元素按照默认规则排序list) public static: 将集合中元素按照指定规则排序void sort(List List,Comparator)
import java.util.ArrayList;
import java.util.Collections;
public class Dem01Collections {
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,5,36,45,89,252,649,159);
System.out.println(list);
System.out.println("==================");
Collections.shuffle(list);
System.out.println(list);
System.out.println("==================");
Collections.sort(list);
System.out.println(list);
}
}
Comparator比较器
比较两种对象之间的大小, Java提供了两种比较实现的方式, 一种是死板的采用 java.lang.Comparable , 还有一种句式自定义的灵活的ava.util.Comparator
Collections 自带的 sort() 实现的就是前者,在comparable接口完成比较的功能
public final class String implements java.io.Serializable, Comparable, CharSequence {}
我自定义的比较器 使用 public static
比较器具有可比性, 两个比较的对象谁排在前排在后, 比较的方法是
public int compare(String s1,String s2) : 比较两个参数的顺序
重写Comparator 的 compare方法
两个对象比较的结果有三种：大于，等于，小于。
如果要按照升序排序，
则o1 小于o2，返回（负数），相等返回0，01大于02返回（正数）
如果要按照降序排序
则o1 小于o2，返回（正数），相等返回0，01大于02返回（负数）
// 比较两个字符串 , 按照第一位的字符串倒序排列
public class CollectionsDemo3 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("cba");
list.add("aba");
list.add("sba");
list.add("nba");
//排序方法 按照第一个单词的降序
Collections.sort(list, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o2.charAt(0) - o1.charAt(0);
}
});
System.out.println(list);
}
}
Comparaable与Comparator的区别
Comparable : 强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器
Comparator : 强行对某个对象进行整体排序。可以将Comparator 传递给sort方法（如Collections.sort或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序
// 自定义一个标准的Student类; 重写Comparable的比较方法
public class Student implements Comparable<Student>{
@Override
public int compareTo(Student o){
return this.age - o.age // 升序
}
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 +
'}';
}
}
// 测试类
public class Demo {
public static void main(String[] args) {
// 创建四个学生对象 存储到集合中
ArrayList<Student> list = new ArrayList<Student>();
list.add(new Student("rose",18));
list.add(new Student("jack",16));
list.add(new Student("abc",16));
list.add(new Student("ace",17));
list.add(new Student("mark",16));
/*
让学生 按照年龄排序 升序
*/
// Collections.sort(list);//要求该list中元素类型 必须实现比较器Comparable接口
for (Student student : list) {
System.out.println(student);
}
}
}
拓展
想要独立的自定义规则, 采用Collections.sort(List list,Comparetor c), 自己定义规则
Collections.sort(list, new Comparator<Student>(){
@Override
public int compare(Student o1,Student 02){
return o2.getAge() - o1.getAge() // 以学生的年龄排序
}
});
如果想要更多规则, 想要在年龄相当的情况下,再次排序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
// 年龄降序
int result = o2.getAge()-o1.getAge();//年龄降序
if(result==0){//第一个规则判断完了 下一个规则 姓名的首字母 升序
result = o1.getName().charAt(0)-o2.getName().charAt(0);
}
return result;
}
});
6 Map
概述
像生活中 IP与主机名, 身份证与个人, 系统用户名与系统用户对象, 这种一一对应的关系,就叫做映射; Java专门提供了专门的集合类用来存放这种对象关系的对象 ,即 java.util.Map 接口
Collection与Map 他们的存储数据的形式不同
Collection中的集合, 元素时孤立存在的, 向集合中存储元素采用一个个元素的方式存储; 它是单列集合Map中的集合, 元素是成对存在的(键值对), 每个元素由键与值两部分组成, 通过键找到所对应的值, 它是双列集合
Map常用子类
常用的有HashMap集合, LinkedHashMap集合
HashMap: 存储数据采用的哈希表结构, 元素的存取顺序不能保证一致, 由于要保证键的唯一, 不重复, 需要重写键的hashCode方法,equals方法LinkedHashMap: 存储数据采用的哈希表+链表结构; 通过链表结构可以保证元素的存取顺序一致, 通过哈希表结构可以保证键的唯一, 不重复, 需要重写键的hashCode()方法、equals()方法
Map接口中的集合都有两个泛型变量(键与值), 在使用时 , 要为两个泛型变量赋予数据类型; 两个泛型变量的数据类型可以相同, 也可以不同
Map接口中常用的方法
Map接口中定义了很多的方法, 常用的如下:
public V put(K key, V value): 把指定的键与指定的值添加到Map集合中public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除, 并且返回被删除元素的值public get(Object key): 根据指定的键, 在Map集合中获取对应的值boolean containsKey(Object Key): 判断集合中是否包含指定的键public Set: 获取Map集合中所有的键, 存储到Set集合中keySet() public Set: 获取到Map集合中所有的键值对对象的集合(Set集合)
public class MapDemo{
public static void main(String[] args){
// 创建map对象
HashMap<String,String> map = new HashMap<String,String>()
// 添加元素到集合
map.put("黄晓明","杨颖");
map.put("文章","马伊琍");
map.put("邓超","孙俪");
System.out.println(map.remove("邓超")) // 返回的是对应的key
// 通过key查看value的值
System.out.println(map.get("黄晓明"))
}
}
注意 :
1 若remove指定的键不存在, 则返回的为null
2 若指定的key在集合中已经存在, 则返回值为替换前的key对应的value, 并把键对应的值, 替换称为新的值
Map集合遍历键找值的方式
先取出Map集合中 所有的键添加到一个 Set集合中, 然后for增强循环这个 Set, 得到每个key从而获取每个键
分析步骤：
- 获取Map中所有的键，由于键是唯一的，所以返回一个Set集合存储所有的键。方法提示:
keyset() - 遍历键的Set集合，得到每一个键。
- 根据键，获取键所对应的值。方法提示:
get(K key)
public class MapDemo{
public static void main(String[] args){
// 创建Map集合对象
HashMap<String,String> map = new HashMap<String,String>();
// 添加元素到集合
map.put("黄晓明","杨颖");
map.put("文章","马伊琍");
map.put("邓超","孙俪");
// 获取所有的键
Set<String> keys = map.keySet();
// 遍历键的集合
for(String key : keys){
// 键 --> 值
String value = map.get(key);
System.out.println(key+"对应的值为"+value);
}
}
}
Entry键值对对象
Map中存放的是两种对象, 一种为key, 一种为value; 他们在Map中是一一对应关系, 这一对对象又称为Map的一个 Entry项, Entry 将键值对的对应关系封装成了对象, 即键值对对象; 这样我们在遍历Map集合时, 就可以从每一个键值对 Entry 对象中获取对应的键与对应的值
Entry 表示一对键和值对象, 也提供了获取对应键和对应值的方法
public K getKey(): 获取Entr对象中的键public V getValue(): 获取Entry对象中的值
从Map集合中获取所有Entry对象的方法:
public Set : 获取到Map集合只能怪所有的键值对 对象的集合(Set集合)
Map集合遍历键值对方式
键值对方式 : 通过集合中每个键值对(Entry)对象, 获取键值对(Entry)对象中的键与值
操作步骤与图解：
- 获取Map集合中，所有的键值对(Entry)对象，以Set集合形式返回。方法提示:
entrySet() - 遍历包含键值对(Entry)对象的Set集合，得到每一个键值对(Entry)对象
- 通过键值对(Entry)对象，获取Entry对象中的键与值。 方法提示:
getkey() getValue()
注意 : Map集合不能直接使用迭代器或者 forearch进行遍历; 但是转成Set之后就可以使用了
public class MapDemo02{
public static void main(String[] args){
// 创建Map集合对象
HashMap<String,String> map = new HashMap<String,String>();
// 添加元素到集合
map.put("胡歌", "霍建华");
map.put("郭德纲", "于谦");
map.put("薛之谦", "大张伟");
// 获取所有的Entry对象
Set<Entry<String,String>> entrySet = map.entrySet();
// 遍历得到每一个entry对象
for(Entry<String,String> entry: entrySet){
// 解析 key,value
String key = entry.getKey();
String value = entry.getValue();
System.out.println(key+"对应的值"+value)
}
}
}
HashMap存储自定义类型键值
练习 : 每位学生对象有(姓名,年龄) , 现在还有各自的家庭住址(String), 将他们存储到map集合当中
key : Student value : String
// 学生类, 需要重写 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;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 测试类
public class HashMapTest{
public static void main(String[] args){
// 创建HashMap集合对象
Map<Student,String> map = new HashMap<Student,String>();
// 添加元素
map.put(new Student("张三",22),"上海");
map.put(new Student("李四",12),"武汉");
map.put(new Student("王五",29),"北京");
map.put(new Student("赵六",19),"南京");
map.put(new Student("孙七",20),"深圳");
// 取出元素, 键找值
Set<Student,String> keySet = map.keySet()
for(Student key:keySet){
String value = map.get(key);
System.out.println(key.toString()+"他的家庭住址 :"+value)
}
}
}
LinkHashMap
HashMap保证成对元素唯一, 并且查询速度很快, 但是成对元素放进去是没得顺序的, 那么我们要保证有序, 就得使用LinkedHashMap, 它是一个链表+哈希表组合的一个数据存储结构
public class LinkedHashMapDemo {
public static void main(String[] args) {
LinkedHashMap<String, String> map = new LinkedHashMap<String, String>();
map.put("邓超", "孙俪");
map.put("李晨", "范冰冰");
map.put("刘德华", "朱丽倩");
Set<Entry<String, String>> entrySet = map.entrySet();
for (Entry<String, String> entry : entrySet) {
System.out.println(entry.getKey() + " " + entry.getValue());
}
}
}
练习 : 计算一个字符串中每个字符出现的次数
获取字符串的 字节,存入集合作为键, 次数作为它的key ; 若存在则++
分析:
- 获取一个字符串对象来记录输入的字符串
- 创建一个Map集合, 键代表字符串中的每个字符, 值代表出现的次数
- 遍历字符串得到每一个字符
- 判断Map集合中是否有以该字符作为键
- 如果没有 , 第一次出现, 存储次数为1; 如果有, 则说明已经出现过, 获取到对应的值++, 再次存储
public class MapTest {
public static void main(String[] args) {
//友情提示
System.out.println("请录入一个字符串:");
String line = new Scanner(System.in).nextLine();
// 定义 每个字符出现次数的方法
findChar(line);
}
private static void findChar(String line) {
//1:创建一个集合 存储 字符 以及其出现的次数
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
//2:遍历字符串
for (int i = 0; i < line.length(); i++) {
char c = line.charAt(i);
//判断 该字符 是否在键集中
if (!map.containsKey(c)) {//说明这个字符没有出现过
//那就是第一次
map.put(c, 1);
} else {
//先获取之前的次数
Integer count = map.get(c);
//count++;
//再次存入 更新
map.put(c, ++count);
}
}
System.out.println(map);
}
}
JDK9对集合添加的优化
在代码中创建一个集合(例如 List或 Set), 并直接使用一些元素填充它, 会调用几个add方法,使得代码重复
在JDK9中, 添加了几种结合工厂方法, 更方便创建少量元素的集合, map示例; 新的List,Set, Map的静态工厂方法可以更方便地创建集合的不可变实例
public class HelloJDK9 {
public static void main(String[] args) {
Set<String> str1=Set.of("a","b","c");
//str1.add("c");这里编译的时候不会错，但是执行的时候会报错，因为是不可变的集合
System.out.println(str1);
Map<String,Integer> str2=Map.of("a",1,"b",2);
System.out.println(str2);
List<String> str3=List.of("a","b");
System.out.println(str3);
}
}
注意 :
1.of() 方法是指Map,Set,List这三个接口的静态方法, 其父类接口和子类并没有这类方法 , 比如HashSet, ArrayList等等;
- 返回的集合是不可变类型
7 Debug追踪与调试
可以让代码逐行执行, 查看代码之心搞得过程, 调试程序中出现的bug
- 在有效代码行 , 点击行号右边的空白区域, 设置断点, 程序执行到断点将停止, 然后手动运行程序
- 点击Debug运行模式
- 程序停止在断点上不再执行, 而在IDEA最下方打开Debug调试窗口
- F8 逐行执行程序 F7进入到方法中 shift+F8 跳出方法 f9跳到下一个断点
- 快捷键F8，代码向下执行一行,第九行执行完毕，执行到第10行（第10行还未执行）
- 快捷键F8，程序继续向后执行, …
- 查看每一步的运行结果 继续F8
- 如果不想继续debug,那么可以使用快捷键F9,程序正常执行到结束，程序结果在控制台显示
8 模拟斗地主案例
分析
具体规则 :
- 组装54张扑克牌
- 将54张牌打乱
- 三个玩家参与游戏, 三人交替摸牌, 每人17张, 最后三张作为底牌
- 最后,查看三个手中各自的牌(按牌的大小排序)
需求分析
- 准备牌 : 完成数字与纸牌的映射关系, 使用HashMap集合, 完成一个数字与字符串纸牌的对应关系
- 洗牌 : 通过数字完成洗牌
- 发牌: 将每个人以及底牌设计为ArrayList, 最后三张直接存放于底牌, 剩余的牌通过对 3 取模依次发牌. 存放的过程中要求数字大小与斗地主规则的大小对应, 将不同纸牌的数字分配给不同的玩家与底牌
- 看牌 : 通过Map结合找到对应字符展示, 通过查询纸牌与数字的对应关系, 由数字转成纸牌字符串再进行展示
分析图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ywSDkLsr-1592011345643)(assets/1589202689567.png)]
代码步骤
public class Poker {
public static void main(String[] args) {
/*
* 1组装54张扑克牌
*/
// 1.1 创建Map集合存储
HashMap<Integer, String> pokerMap = new HashMap<Integer, String>();
// 1.2 创建 花色集合 与 数字集合
ArrayList<String> colors = new ArrayList<String>();
ArrayList<String> numbers = new ArrayList<String>();
// 1.3 存储 花色 与数字
Collections.addAll(colors, "♦", "♣", "♥", "♠");
Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4", "3");
// 设置 存储编号变量
int count = 1;
pokerMap.put(count++, "大王");
pokerMap.put(count++, "小王");
// 1.4 创建牌 存储到map集合中
for (String number : numbers) {
for (String color : colors) {
String card = color + number;
pokerMap.put(count++, card);
}
}
/*
* 2 将54张牌顺序打乱
*/
// 取出编号 集合
Set<Integer> numberSet = pokerMap.keySet();
// 因为要将编号打乱顺序 所以 应该先进行转换到 list集合中
ArrayList<Integer> numberList = new ArrayList<Integer>();
numberList.addAll(numberSet);
// 打乱顺序
Collections.shuffle(numberList);
// 3 完成三个玩家交替摸牌，每人17张牌，最后三张留作底牌
// 3.1 发牌的编号
// 创建三个玩家编号集合 和一个 底牌编号集合
ArrayList<Integer> noP1 = new ArrayList<Integer>();
ArrayList<Integer> noP2 = new ArrayList<Integer>();
ArrayList<Integer> noP3 = new ArrayList<Integer>();
ArrayList<Integer> dipaiNo = new ArrayList<Integer>();
// 3.2发牌的编号
for (int i = 0; i < numberList.size(); i++) {
// 获取该编号
Integer no = numberList.get(i);
// 发牌
// 留出底牌
if (i >= 51) {
dipaiNo.add(no);
} else {
if (i % 3 == 0) {
noP1.add(no);
} else if (i % 3 == 1) {
noP2.add(no);
} else {
noP3.add(no);
}
}
}
// 4 查看三人各自手中的牌（按照牌的大小排序）、底牌
// 4.1 对手中编号进行排序
Collections.sort(noP1);
Collections.sort(noP2);
Collections.sort(noP3);
Collections.sort(dipaiNo);
// 4.2 进行牌面的转换
// 创建三个玩家牌面集合 以及底牌牌面集合
ArrayList<String> player1 = new ArrayList<String>();
ArrayList<String> player2 = new ArrayList<String>();
ArrayList<String> player3 = new ArrayList<String>();
ArrayList<String> dipai = new ArrayList<String>();
// 4.3转换
for (Integer i : noP1) {
// 4.4 根据编号找到 牌面 pokerMap
String card = pokerMap.get(i);
// 添加到对应的 牌面集合中
player1.add(card);
}
for (Integer i : noP2) {
String card = pokerMap.get(i);
player2.add(card);
}
for (Integer i : noP3) {
String card = pokerMap.get(i);
player3.add(card);
}
for (Integer i : dipaiNo) {
String card = pokerMap.get(i);
dipai.add(card);
}
//4.5 查看
System.out.println("令狐冲："+player1);
System.out.println("石破天："+player2);
System.out.println("鸠摩智："+player3);
System.out.println("底牌："+dipai);
}
}
tring>();
ArrayList player2 = new ArrayList();
ArrayList player3 = new ArrayList();
ArrayList dipai = new ArrayList();
// 4.3转换
for (Integer i : noP1) {
// 4.4 根据编号找到 牌面 pokerMap
String card = pokerMap.get(i);
// 添加到对应的 牌面集合中
player1.add(card);
}
for (Integer i : noP2) {
String card = pokerMap.get(i);
player2.add(card);
}
for (Integer i : noP3) {
String card = pokerMap.get(i);
player3.add(card);
}
for (Integer i : dipaiNo) {
String card = pokerMap.get(i);
dipai.add(card);
}
//4.5 查看
System.out.println(“令狐冲：”+player1);
System.out.println(“石破天：”+player2);
System.out.println(“鸠摩智：”+player3);
System.out.println(“底牌：”+dipai);
}
}