异常
-
异常概述
异常：就是程序出现了不正常的情况
异常体系
Error：严重问题，不需要处理
Exception：称为异常类，它表示程序本身可以处理的问题
- RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码
- 非RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了
-
JVM的默认处理方案
如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理
- 把异常的名称、异常原因及异常出现的位置等信息输出在了控制台
- 程序停止执行
-
异常处理
如果程序出现了问题，我们需要自己来处理，有两种方案：
- try …catch …
- throws
-
异常处理之try …catch …
-
格式“
try{
肯出现异常的代码；
}catch(异常类名 变量名){
异常的处理代码；
}
执行流程：
程序从try里面的代码开始执行
出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统
当Java运行时系统接受到异常对象时，会到catch中去找匹配的异常类，找到后进行异常处理
执行完毕后，程序还可以继续往下执行
package heima01; public class ExceptionDemo01 { public static void main(String[] args) { System.out.println("开始"); method(); System.out.println("结束"); } public static void method() { try { int[] arr = {1, 2, 3}; System.out.println(arr[3]);//new ArrayIndexOutOfBoundsException(); // System.out.println(arr[2]); } catch (ArrayIndexOutOfBoundsException e) { // System.out.println("你访问的数组的索引不存在"); e.printStackTrace(); } } }
-
-
Throwable的成员方法
方法名 说明 public String getMessage() 返回throwable的详细信息字符串 public String toString() 返回此可抛出的简短描述 public void printStackTrace() 把异常的错误信息输出在控制台 public static void method() { try { int[] arr = {1, 2, 3}; System.out.println(arr[3]);//new ArrayIndexOutOfBoundsException(); } catch (ArrayIndexOutOfBoundsException e) { // System.out.println("你访问的数组的索引不存在"); // System.out.println(e.getMessage()); // System.out.println(e.toString()); e.printStackTrace();//一般使用这个方法将错误信息输出 } } -
编译时异常和运行时异常的区别
Java中的异常被分为两大类：编译时异常和运行时异常，也被称为受检异常和非受检异常
所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常
- 编译时异常：必须显示处理，否则程序就会发生错误，无法通过编译
- 运行时异常：无需显示处理，也可以和编译时异常一样处理
-
异常处理之throws
虽然我们通过try … catch … 可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常处理，也就是说，有些时候可能出现的异常是我们处理不了的
针对这种情况，Java提供了throws的处理方案
格式：
throws 异常类名；
注意：这个格式是跟在方法的括号后面的
public static void main(String[] args) { // method(); try { method2(); } catch (ParseException e) { e.printStackTrace(); } } //编译时异常 public static void method2() throws ParseException { String s = "2022-03-13"; SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd"); Date d = sdf.parse(s);//抛出一个异常,调用该方法的时候再try...catch... System.out.println(d); }- 编译时异常必须要进行处理，两种处理方案：try…catch…或者 throws, 如果采用throws这种方案，将来谁调用谁处理
- 运行时异常可以不处理，出现问题后，需要我们回来修改代码
-
自定义异常
格式：
public class 异常类名 extends Exception{
无参构造
带参构造
}
范例：
public class ScoreException extends Exception{
public ScoreException（）{}
public ScoreException(String message){
super(message);
}
}
package heima02; public class ScoreException extends Exception { public ScoreException() { } public ScoreException(String message) { super(message); } }package heima02; public class Teacher { public void checkScore(int score) throws ScoreException { if (score < 0 || score > 100) { throw new ScoreException(); } else { System.out.println("分数正常"); } } }package heima02; import java.util.Scanner; public class TeacherTest { public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.println("请输入分数:"); int score = sc.nextInt(); Teacher t=new Teacher(); try { t.checkScore(score); } catch (ScoreException e) { e.printStackTrace(); } } }该方法下，如果输入的分数不正常时，没有输出异常的原因，故不用该无参构造方法，而使用带参构造方法
package heima02; public class Teacher { public void checkScore(int score) throws ScoreException { if (score < 0 || score > 100) { // throw new ScoreException(); throw new ScoreException("你给的分数有误,分数应当在0-100之间"); } else { System.out.println("分数正常"); } } } -
throws和throw的区别
throws
- 用在方法声明后面，跟的时异常类名
- 表示抛出异常，由该方法的调用者来处理
- 表示出现异常的一种可能性，并不一定会发生这些异常
throw
- 用在方法体内，跟的时异常对象名
- 表示抛出异常，由方法体内的语句处理
- 执行throw一定抛出了某种异常
集合进阶
-
Collection
-
集合知识回顾
集合的特点：提供了一种存储空间可变的存储模型，存储的数据容量可以随时发生改变
-
集合体系结构
单列，如：
张三 李四 王五 双列，如：
itcast1 张三 itcast2 李四 itcast3 王五 list，可重复，如：
张三 李四 张三 set，不可重复，如：
张三 李四 -
Collection集合概述和使用
Collection集合概述
- 是单例集合的顶层接口，它表示一组对象，这些对象也称为Collection的元素
- JDK不提供此接口的任何直接实现，它提供更具体的子接口(如Set和List)实现
创建Collection集合的对象
- 多态的方式
- 具体的实现类ArrayList
-
Collection集合常用方法
方法名 说明 boolean add (E e) 添加元素 boolean remove(Object o) 从集合中移除指定的元素 void clear() 清空集合中的元素 boolean contains(Object o) 判断集合中是否存在指定的元素 boolean isEmpty() 判断集合是否为空 int size() 集合的长度，也就是集合中元素的个数 package heima03; import java.util.ArrayList; import java.util.Collection; public class CollectionDemo02 { public static void main(String[] args) { Collection<String> c = new ArrayList<String>(); //boolean add(E e);添加元素 System.out.println(c.add("hello")); System.out.println(c.add("world")); System.out.println(c.add("world")); //boolean remove(Object o);从集合中移除指定的元素 System.out.println(c.remove("world")); // void clear(); 清空集合中的元素 // c.clear(); //boolean isEmpty();判断集合是否为空 System.out.println(c.isEmpty()); //int size();集合的长度，也就是集合中元素的个数 System.out.println(c.size()); System.out.println(c); } }运行结果：
true
true
true
true
false
2
[hello, world]Process finished with exit code 0
-
Collection集合的遍历
Iterator:迭代器，集合的专用遍历方式
- Iterator iterator():返回此集合中元素的迭代器，通过集合的iterator()方法得到
- 迭代器史通过集合的iterator()方法得到的，所有我们说它是依赖于集合而存在的
Iterator中的常用方法
-
E next(): 返回迭代中的下一个元素
-
boolean hasNext(): 如果迭代具有更多元素，则返回true；
package heima03; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionDemo02 { public static void main(String[] args) { //创建集合对象 Collection<String> c = new ArrayList<String>(); //添加元素 c.add("hello"); c.add("world"); c.add("java"); //Iterator<E> iterator():返回此集合中元素的迭代器，通过集合的iteratorF()方法得到 Iterator<String> it = c.iterator();//通过多肽类得到iterator对象 //E next(): 返回迭代中的下一个元素 System.out.println(it.next());//输出hello System.out.println(it.next());// world System.out.println(it.next());// java // System.out.println(it.next());//NoSuchElementException 被请求访问的元素不存在 //boolean hasNext(): 如果迭代具有更多元素，则返回true； if (it.hasNext()) { System.out.println(it.next()); } if (it.hasNext()) { System.out.println(it.next()); } if (it.hasNext()) { System.out.println(it.next()); } if (it.hasNext()) { System.out.println(it.next()); } //用while循环改进判断 while (it.hasNext()) { // System.out.println(it.next()); String s = it.next(); System.out.println(s); } } }
-
集合的使用步骤
-
案例：Collection集合存储学生对象并遍历
需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历该集合
实现思路：
- 定义学生类
- 创建Collection集合对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合（迭代器方式）
package heima04; //定义学生类 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; } }package heima04; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class CollectionDemo { public static void main(String[] args) { //创建Collection集合对象 Collection<Student> c = new ArrayList<Student>(); //创建学生对象 Student s1 = new Student("ling", 30); Student s2 = new Student("zhang", 35); Student s3 = new Student("wang", 30); //把学生添加到集合 c.add(s1); c.add(s2); c.add(s3); //遍历集合（迭代器方式） Iterator<Student> it = c.iterator(); while (it.hasNext()) { Student s = it.next(); System.out.println(s.getName() + "," + s.getAge()); } } }
-
-
List
-
List集合概述和特点
List集合概述
- 有序集合（也成为序列），用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引访问元素，并搜索列表中的元素
- 与Set集合不同，列表通常允许重复的元素
List集合特点
- 有序：存储和取出的元素顺序一致
- 可重复：存储的元素可以重复
package heima05; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ListDemo01 { public static void main(String[] args) { //创建集合对象 List<String> list = new ArrayList<String>(); //添加元素 list.add("hello"); list.add("world"); list.add("java"); list.add("java"); //输出集合对象 // System.out.println(list); //迭代器的方式遍历 Iterator<String> it = list.iterator(); while (it.hasNext()) { String s = it.next(); System.out.println(s); } } } -
List集合特有方法
方法名 说明 void add(int index,E element) 在此集合中的指定位置插入指定的元素 E remove(int index) 删除指定索引处的元素，返回被删除的元素 E set(int index,E element) 修改指定索引处的元素，返回被修改的元素 E get(int index) 返回指定索引处的元素 -
并发修改异常
并发修改异常
- ConcurrentModificationException
产生原因
- 迭代器遍历的过程中，通过集合对象修改了元素的长度，造成了迭代器获取元素中判断预期修改值和实际修改值不一致
解决方案
- 用for循环遍历，然后用集合对象做对应的操作即可
-
ListIterator
LisIterator：列表迭代器
- 通过List集合的listIterator()方法得到，所以说它是List集合特有的迭代器
- 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
ListIterator中的常用方法
- E next():返回迭代中的下一个元素
- boolean hasNext():如果迭代具有更多元素，则返回true
- E previous():返回列表中的上一个元素
- boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
- void add(E e):将指定的元素插入列表
ListIterator<String> lit = list.listIterator(); while (lit.hasNext()) { String s = lit.next(); System.out.println(s); } System.out.println("--------------------"); while (lit.hasPrevious()) { String s = lit.previous(); System.out.println(s); } -
增强for循环
增强for：简化数组和Collection集合的遍历
- 实现Iterator接口的类允许其对象成为增强型for语句的目标
- 它时JDK之后出现的，其内部原理是一个Iterator迭代器
增强for的格式
-
格式：
for(元素书籍类型变量名：数组或者Collection集合){
//在此处使用遍历即可，该变量就是元素
}
-
范例：
int[] arr={1,2,3,4,5};
for(int i:arr){
System.out.println(i);
}
public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5}; for (int i : arr) { System.out.println(i); } System.out.println("--------------"); String[] atrArray = {"hello", "world", "java"}; for (String s : atrArray) { System.out.println(s); } System.out.println("--------------"); List<String> list = new ArrayList<String>( list.add("hello"); list.add("world"); list.add("java"); for (String s : list) { System.out.println(s); } System.out.println("--------------"); // for (String s : list) { if (s.equals("world")) { list.add("javaee"); } } }案例：List集合存储学生对象用三种方式遍历
需求：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台编辑该集合
思路：
-
定义学生类
-
创建List集合对象
-
创建学生对象
-
把学生添加到集合
-
遍历集合
迭代器：集合特有的遍历方式
普通for：带有索引的遍历方式
增强for：最方便的遍历方式
package heima06; import heima04.Student; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.ListIterator; public class ListDemo { public static void main(String[] args) { //创建List集合对象 List<Student> list = new ArrayList<Student>(); //创建学生对象 Student s1 = new Student("ling", 19); Student s2 = new Student("wang", 18); Student s3 = new Student("chen", 19); //添加学生到集合 list.add(s1); list.add(s2); list.add(s3); //迭代器遍历集合 Iterator<Student> it = list.iterator(); while (it.hasNext()) { Student s = it.next(); System.out.println(s.getName() + "," + s.getAge()); } System.out.println("--------------------"); //普通for：带有索引的遍历方式 for (int i = 0; i < list.size(); i++) { Student s = list.get(i); System.out.println(s.getName() + "," + s.getAge()); }//如果操作过程中要使用索引，就使用普通for System.out.println("--------------------"); //增强for for (Student s : list) { System.out.println(s.getName() + "," + s.getAge()); }//如果只是遍历，使用增强for } }
-
-
数据结构
数据结构是计算机存储、组织数据的方式，是指相互之间存在一种或多种特定关系的数据元素的集合
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率
-
常见数据结构之栈
-
常见数据结构之队列
-
常见数据结构之数组
-
常见数据结构之链表
-
List集合子类特点
List集合常用子类：ArrayList、LinkedList
- ArrayList：底层数据结构是数组，查询快，增删瞒
- LinkedList：底层数据结构是链表，查询慢，增删快
练习：分别使用ArrayList和LinkedList完成存储字符串并遍历
-
LinkedList集合特有的功能
方法名 说明 public void addFirst(E e) 在该列表开头插入指定的元素 public void addLast(E e) 将指定的元素追加到此列表的末尾 public E getFirst() 返回此列表中的第一个元素 public E getLast() 返回此列表中的最后一个元素 public E removeFirst() 从此列表中删除并返回第一个元素 public E removeLast() 从此列表中删除并返回最后一个元素
-
-
Set
-
Set集合概述和特点
Set集合特点
- 不包含重复元素的集合
- 没有带索引的方法，所以不能使用普通for循环遍历
HashSet：对集合的迭代器顺序不作任何保证
Set集合联系
- 存储字符串并遍历
package heima08; import java.util.HashSet; import java.util.Set; public class SetDemo { public static void main(String[] args) { //创建集合对象 Set<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); } } }输出结果：
world
java
hello -
哈希值
哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
- public int hashCode(): 返回对象的哈希码值
package heima09; public class HashDemo { public static void main(String[] args) { Student s1 = new Student("ling", 30); //同一个对象多次调用hashCode()方法返回的哈希值是相同的 System.out.println(s1.hashCode()); System.out.println(s1.hashCode());//685325104 System.out.println("---------------------------------------"); Student s2 = new Student("ling", 30); //默认情况下，不同对象的哈希值是不同的 System.out.println(s2.hashCode());//460141958 } }package heima09; public class HashDemo { public static void main(String[] args) { Student s1 = new Student("ling", 30); //同一个对象多次调用hashCode()方法返回的哈希值是相同的 System.out.println(s1.hashCode()); System.out.println(s1.hashCode());//685325104 System.out.println("---------------------------------------"); Student s2 = new Student("ling", 30); //默认情况下，不同对象的哈希值是不同的 //通过方法重写，可以实现不同对象的哈希值是不同的 System.out.println(s2.hashCode());//460141958 System.out.println("--------------------------------"); System.out.println("hello".hashCode());//99162322 System.out.println("world".hashCode());//113318802 System.out.println("java".hashCode());//3254818 System.out.println("hello".hashCode());//99162322 System.out.println("---------------------------------"); System.out.println("重地".hashCode()); System.out.println("童话".hashCode()); } }对象的哈希值特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 默认情况下，不同对象的哈希值是不同的。而重写hashCode()方法，可以实现让不同对象的哈希值相同
-
HashSet集合概述和特点
HashSet集合特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是Set集合，所以是不包含重复元素的集合
-
HashSet集合保证元素唯一性源码分析
HashSet集合添加一个元素的过程：
HashSet集合存储元素：
- 要保证元素唯一性，需要重写hashCode()和equals()
-
常见数据结构之哈希表
哈希表
- JDK8之前，底层采用数组+链表实现，可以说是一个元素为链表的数组
- JDK8之后，在长度比较长的时候，底层实现了优化
对16取余后按结果存储，如取余结果都为2，则先比较哈希值，如果哈希值不同则用链表方式存储在2位置，如果哈希值相同再比较元素，如果元素也相同则不存储
案例：HashSet集合存储学生对象并遍历
需求：创建一个存储学生对象的集合，存储多个学生对象，使用程序实现在控制台遍历集合
要求：学生对象的成员变量值相同，我们就认为是同一个对象
思路：
- 定义学生类
- 创建HashSet对象
- 创建学生对象
- 把学生添加到集合
- 遍历集合(增强for)
-
在学生类中重写两个方法 hashCode()和equals() 自动生成即可
package heima10; 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; } }package heima10; import java.util.HashSet; public class HashSetDemo { public static void main(String[] args) { //创建集合对象 HashSet<Student> hs = new HashSet<Student>(); //创建学生对象 Student s1 = new Student("ling", 19); Student s2 = new Student("wang", 19); Student s3 = new Student("cai", 18); Student s4 = new Student("wang", 19); //把学生添加到集合 hs.add(s1); hs.add(s2); hs.add(s3); hs.add(s4);//为保证添加元素的唯一性，我们需要重写HashCode方法 //遍历 for (Student s : hs) { System.out.println(s.getName() + "," + s.getAge()); } } }
-
LinkedHashSet集合概述和特点
LinkedHashSet集合特点
- 哈希表和链表实现Set接口，具有可预测的迭代次序
- 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
- 由哈希表保证元素唯一，也就是说没有重复的元素
LinkedHashSet集合练习
- 存储字符串TreeSet集合并遍历
-
TreeSet集合概述和特点
TreeSet集合
-
元素有序，这里的顺序不是指存储和取出的顺序，而是按照一定的规则进行排序，具体排序方法取决于构造方
TreeSet():根据其元素的自然排序进行排序
TreeSet(Comparator comparator):根据指定的比较强进行排序
-
没有带索引的方法，所以不能使用普通for循环遍历
-
由于是Set集合，所以不包含重复元素的集合
TreeSet集合练习
- 存储整数并遍历
package heima12; import java.util.TreeSet; public class TreeSetDemo01 { public static void main(String[] args) { //创建集合对象 TreeSet<Integer> ts = new TreeSet<Integer>();//集合存储的是引用类类型，应该使用int类型的包装类类型Integer //添加元素 ts.add(98); ts.add(20); ts.add(50); ts.add(30); ts.add(10); ts.add(30); // for (Integer i : ts) { System.out.println(i); } } } -
-
自然排序Comparable的使用
- 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照名字的字母顺序排序
结论
- 用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
- 自然排序，就是让元素所属的类实现Comparable接口，重写comparableTo(To) 方法
- 重写方法时，一定要注意排序规则按照要求的注意条件和次要条件来写
package heima12; 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 int compareTo(Student s) {//若返回0，则说明元素是重复的，就不会存储，结果只输出一项值；若返回1，则升序存储；若返回-1，则降序存储 // return 0; //按年龄从小到大排序 int num = this.age - s.age;//升序this放前面，降序this放后面 int num2 = num == 0 ? this.name.compareTo(s.name) : num; return num2; } }package heima12; import java.util.TreeSet; public class TreeSetDemo02 { public static void main(String[] args) { //创建集合对象 TreeSet<Student> ts = new TreeSet<Student>(); //创建学生对象 Student s1 = new Student("xishi", 19); Student s2 = new Student("diaochan", 18); Student s3 = new Student("yang", 20); Student s4 = new Student("wang", 21); Student s5 = new Student("ling", 21); System.out.println("-----------------------------------"); //把学生类添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //遍历集合 //要实现对类的自然排序，该类需要实现comparable 接口 for (Student s : ts) { System.out.println(s.getName() + "," + s.getAge()); } } } -
比较器排序Comparator的使用
- 存储学生对象并遍历，创建TreeSet集合使用代餐构造方法
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
package heima12; 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; } }package heima12; import java.util.Comparator; import java.util.TreeSet; public class TreeSetDemo02 { public static void main(String[] args) { //创建集合对象 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { //this.age-s.age; //s1 s2 int num = s1.getAge() - s2.getAge(); int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return num2; } }); //创建学生对象 Student s1 = new Student("xishi", 19); Student s2 = new Student("diaochan", 18); Student s3 = new Student("yang", 20); Student s4 = new Student("wang", 21); Student s5 = new Student("ling", 21); System.out.println("-----------------------------------"); //把学生类添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //遍历集合 //要实现对类的自然排序，该类需要实现comparable 接口 for (Student s : ts) { System.out.println(s.getName() + "," + s.getAge()); } } }结论：
- 用TreeSet集合存储自定义对象，带参构造方法使用的时比较强排序对元素进行 排序的
- 比较器排序，就是让集合构造方法接受Comparator的实现类对象，重写compara(T o1,T o2)方法
- 重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
案例：成绩排序
要求：用TreeSet集合存储多个学生信息(姓名，语文成绩，数学成绩)，并遍历该集合，按照总分从高到低出现
思路：
- 定义学生类
- 创建TreeSet集合对象，通过比较器进行排序
- 创建学生对象
- 把学生对象添加到集合
- 遍历集合
-
-
泛型
-
泛型概述f
泛型：是JDK中引入的特征，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它本质是参数化类型，也就是说所操作的数据类型被指定为一个参数
一提到参数，最熟悉的就是定义方法时由形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？
顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
泛型定义格式：
- <类型>：指定一种类型的格式。这里的类型可以看成是形参
- <类型1，类型2…>：指定多种类型的格式，多种类型之间用逗号隔开。这里的类型可以看成是形参
- 将来具体调用时给定的类型可以看成是实参，并且实参的类型只能是引用数据类型
泛型的好处：
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换
package heima13; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class GenericDemo { public static void main(String[] args) { //创建集合对象 // Collection c=new ArrayList(); Collection<String> c = new ArrayList<String>(); //添加元素 c.add("hello"); c.add("world"); c.add("java"); // c.add(100); //遍历集合 // Iterator it = c.iterator(); Iterator<String> it = c.iterator(); while (it.hasNext()) { // Object obj = it.next(); // System.out.println(obj); // String s=(String)it.next(); String s = it.next(); System.out.println(s); } } } -
泛型类
泛型类的定义格式：
-
格式：修饰符class类名<类型>{}
-
范例：public class Generic{}
此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
package heima14; public class Generic<T> { private T t; public T getT() { return t; } public void setT(T t) { this.t = t; } }package heima14; public class GenericDemo { public static void main(String[] args) { Student s = new Student(); s.setName("ling"); System.out.println(s.getName()); Teacher t = new Teacher(); t.setAge(30); System.out.println(t.getAge()); System.out.println("------------------------"); Generic<String> g1 = new Generic<String>(); g1.setT("ling"); System.out.println(g1.getT()); Generic<Integer> g2 = new Generic<Integer>(); g2.setT(30); System.out.println(g2.getT()); Generic<Boolean> g3 = new Generic<Boolean>(); g3.setT(true); System.out.println(g3.getT()); } } -
-
泛型方法
泛型方法的定义格式：
- 格式：修饰符<类型> 返回值类型方法名(类型 遍历名){}
- 范例： public void show(T t){}
package heima15; /*public class Generic { public void show(String s){ System.out.println(s); } public void show(Integer i){ System.out.println(i); } public void show(Boolean b){ System.out.println(b); } }*/ //泛型类改进 /*public class Generic<T> { public void show(T t){ System.out.println(t); }*/ //泛型方法改进 public class Generic { public <T> void show(T t) { System.out.println(t); } }package heima15; public class GenericDemo { public static void main(String[] args) { // Generic g=new Generic(); // g.show("ling"); // g.show(30); // g.show(true); /*Generic<String> g1=new Generic<String>(); g1.show("ling"); Generic<Integer> g2=new Generic<Integer>(); g2.show(30); Generic<Boolean> g3=new Generic<Boolean>(); g3.show(true);*/ Generic g = new Generic(); g.show("ling"); g.show(30); g.show(true); g.show(12.34); } } -
泛型接口
泛型接口的定义格式：
- 格式：修饰符interface 接口名<类型>{}
package heima16; public interface Generic<T> { void show(T t); }package heima16; public class GenericImpl<T> implements Generic<T> { @Override public void show(T t) { System.out.println(t); } }package heima16; public class GenericDemo { public static void main(String[] args) { Generic<String> g1=new GenericImpl<String>(); g1.show("ling"); Generic<Integer> g2=new GenericImpl<Integer>(); g2.show(30); } } -
类型通配符
为了表示各种泛型List的父类，可以使用类型通配符
- 类通配符：<?>
- List<?>:表示元素类型未知的List，它的元素可以皮牌任何的类型
- 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
如果说我们不希望List<?>是任何泛型List的父类，只希望它代表某一类泛型List的父类，可以使用类型通配符的上限
- 类型通配符上限：<?extends 类型>
- List<? extends Number>:它表示的类型是Number或者其子类型
除了可以指定类型通配符的上限，我们也可以指定类型通配符下限
- 类型通配符下限：<?super 类型>
- List<? super Number>:它表示的类型是Number或者父类型
package heima17; import com.sun.org.apache.xerces.internal.xs.datatypes.ObjectList; import java.util.ArrayList; import java.util.List; public class GenericDemo { public static void main(String[] args) { //类型通配符：<?> List<?> list1 = new ArrayList<Object>(); List<?> list2 = new ArrayList<Number>(); List<?> list3 = new ArrayList<Integer>(); //类型通配符上限：<? extends 类型> // List<? extends Number> list4=new ArrayList<Object>();//报错，上限为Number，不能由Object继承 List<? extends Number> list5 = new ArrayList<Number>(); List<? extends Number> list6 = new ArrayList<Integer>(); // List<? super Number> list7 = new ArrayList<Object>(); List<? super Number> list8 = new ArrayList<Number>(); // List<? super Number> list9=new ArrayList<Integer>();//报错 } } -
可变参数
可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
- 格式：修饰符 返回值类型 方法名(数据类型… 变量名){}
- 范例：public static int sum(int … a){}
可变参数注意事项
- 这里的变量其实是一个数组
- 如果一个方法有多个参数，包含可变参数，可变参数要放在最后
-
可变参数的使用
Arrays工具类中有一个静态方法：
- public static List asList(T… a):返回由指定数组支持的固定大小的列表
- 返回的集合不能做增删操作，可以做修改操作
List接口中有一个静态方法：
- public static List of(E… elements):返回包含任意数量元素的不可变列表
- 返回的集合不能做增删改操作
Set接口中有一个静态方法：
- public static Set of(E… elements):返回一个包含任意数量元素的不可变集合
- 在给元素的时候，不能给重复的元素
- 返回的集合不能做增删操作，没有修改的方法
package heima18; import java.util.Arrays; import java.util.List; import java.util.Set; public class ArgsDemo02 { public static void main(String[] args) { /* List<String> list = Arrays.asList("hello", "world", "java"); // list.add("javaee");//UnsupportedOperationException不支持请求操作 // list.remove("hello");//UnsupportedOperationException list.set(1,"javaee"); System.out.println(list);*/ // List<String> list=List.of("hello","world","java"); /* list.add("javaee");//UnsupportedOperationException list.remove("hello");//UnsupportedOperationException list.set(1,"javaee");//UnsupportedOperationException*/ // System.out.println(list); // Set<String> set=new Set.of("hello","world","java","hello");//元素不可重复 Set<String> set = new Set.of("hello", "world", "java", "hello"); // set.add("javaee");//UnsupportedOperationException // set.remove("hello");//UnsupportedOperationException System.out.println(set); } }
-
-
Map
-
Map集合的概述和使用
Map集合概述
-
Interface Map<K,V> K:键的类型； V：值的类型
-
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
-
举例：学生的学号和姓名
itheima001 张三
itheima001 李四
itheima003 王五
创建Map集合的对象
-
多态的方式
-
具体的实现类HashMap
方法名 说明 V put(K key,V value) 添加元素 V remove(Object key) 根据键删除键值对元素 void clear() 移除所有键值对元素 boolean containsKey(Object key) 判断集合是否包含指定的键 boolean containsValue(Object value) 判断集合是否包含指定的值 boolean isEmpty() 判断集合是否为空 int size() 集合的长度，也就是集合中键值对的个数
-
-
Map集合的获取功能
方法名 说明 V get(Object key) 根据键获取值 Set keySet() 获取所有键的集合 Collection values() 获取所有值的集合 Set<Map.Entry<K,V>>entrySet() 获取所有键值对对象的集合 package heima19; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class MapDemo03 { public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); //添加元素 map.put("001", "张三"); map.put("002", "李四"); map.put("003", "王五"); //V get(Object key)根据键获取值 System.out.println(map.get("001")); System.out.println(map.get("004")); //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); } } } -
Map集合的遍历（方式1）
- 获取所有键的集合。用keySet() 方法事项
- 遍历键的集合，获取每一个键。用增强for实现
- 根据键去找值。用get(Object key)方法实现
package heima19; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class MapDemo03 { public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); //添加元素 map.put("001", "张三"); map.put("002", "李四"); map.put("003", "王五"); //Set<K> keySet()获取所有键的集合 Set<String> keySet = map.keySet(); //获取所有键的集合。用keySet()方法实现 for (String key : keySet) { //根据键去找值。用get(Object key)方法实现 String value = map.get(key); System.out.println(key + "," + value); } } } -
Map集合的遍历(方式2)
-
获取所有键值对对象的集合
Set<Map.Entry<K,V>>entrySet():获取所有键值对对象的集合
-
遍历键值对对象的集合，得到一个键值对对象
用增强for实现，得到每一个Map.Entry
-
根据键值对对象获取键和值
用getKey()得到键
用getValue()得到值
package heima19; import java.util.Collection; import java.util.HashMap; import java.util.Map; import java.util.Set; public class MapDemo03 { public static void main(String[] args) { Map<String, String> map = new HashMap<String, String>(); //添加元素 map.put("001", "张三"); map.put("002", "李四"); map.put("003", "王五"); //获取所有键值对对象的集合 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); } } } -
案例：HashMap集合存储学生对象并遍历
需求：创建一个HashMap集合，键时学号(String),值是学生对象(Student)。存储三个键值对元素，并遍历。
思路：
-
定义学生类
-
创建HashMap集合对象
-
创建学生对象
-
把学生添加到集合
-
遍历集合
方式1：键找值
方式2：键值对对象找键和值
package heima20; import java.util.HashMap; import java.util.Map; import java.util.Set; public class HashMapDemo { public static void main(String[] args) { //创建HashMap集合对象 HashMap<String, Student> hm = new HashMap<String, Student>(); //创建学生对象 Student s1 = new Student("zhangsan", 19); Student s2 = new Student("lisi", 18); Student s3 = new Student("wangwu", 19); //把学生添加到集合 hm.put("001", s1); hm.put("002", s2); hm.put("003", s3); //遍历集合 //方式1：键找值 Set<String> keySet = hm.keySet(); for (String key : keySet) { Student value = hm.get(key); System.out.println(key + "," + value.getName() + "," + value.getAge()); } System.out.println("---------------------------------------"); //方式2：键值对对象找键和值 Set<Map.Entry<String, Student>> entrySet = hm.entrySet(); for (Map.Entry<String, Student> me : entrySet) { String key = me.getKey(); Student value = me.getValue(); System.out.println(key + "," + value.getName() + "," + value.getAge()); } } }案例：HashMap集合存储学生对象并遍历
需求：创建一个 Hash Map集合，键是学生对象(Student),值是居住地(String)。存储多个键值对元素，并遍历。要求保证键的唯一性：如果学生对象的成员遍历值相同，我们就认为是同一个对象。
思路：
-
定义学生类
-
创建HashMap集合对象
-
创建学生对象
-
把学生添加到集合
-
遍历集合
-
在学生类中重写两个方法
hashCode()
equals()
package heima20; 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; } }package heima20; 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("zhangsan", 19); Student s2 = new Student("lisi", 18); Student s3 = new Student("wangwu", 19); Student s4 = new Student("wangwu", 19); //把学生添加到集合 hm.put(s1, "xian"); hm.put(s2, "wuhan"); hm.put(s3, "tianjin"); hm.put(s4, "guangzhou");//重写HashCode()和equals()方法后，相同键值的value可覆盖 //遍历集合 //方式1：键找值 Set<Student> keySet = hm.keySet(); for (Student key : keySet) { String value = hm.get(key); System.out.println(key.getName() + "," + key.getAge() + "," + value); } } }案例：ArrayList集合存储HashMap元素并遍历
需求：创建一个ArrayList集合，存储三个元素，每一个元素都是HashMap，每一个HashMap的键和值都是String，并遍历
思路：
- 创建ArrayList集合
- 创建HashMap集合，并添加键值对元素
- 把HashMap作为元素添加到ArrayList集合
package heima20; import java.util.ArrayList; import java.util.HashMap; import java.util.Set; public class ArrayListIncludeHashMapDemo { public static void main(String[] args) { //创建ArrayList集合 ArrayList<HashMap<String, String>> array = new ArrayList<HashMap<String, String>>(); //创建HashMap集合，并添加键值对元素 HashMap<String, String> hm1 = new HashMap<String, String>(); hm1.put("001", "zhangsan"); hm1.put("002", "lisi"); //把HashMap作为元素添加到ArrayList集合 array.add(hm1); HashMap<String, String> hm2 = new HashMap<String, String>(); hm2.put("003", "jia"); hm2.put("004", "yi"); //把HashMap作为元素添加到ArrayList集合 array.add(hm2); HashMap<String, String> hm3 = new HashMap<String, String>(); hm3.put("005", "bing"); hm3.put("006", "ding"); //把HashMap作为元素添加到ArrayList集合 array.add(hm3); //遍历ArrayList集合 for (HashMap<String, String> hm : array) { Set<String> keySet = hm.keySet(); for (String key : keySet) { String value = hm.get(key); System.out.println(key + "," + value); } } } }案例：HashMap集合存储ArrayList元素并遍历
需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素是String，值是ArrayList，每一个ArrayLIst是String，并遍历。
思路：
- 创建HashMap集合
- 创建ArrayList集合，并添加到HashMap集合
- 遍历HashMap集合
package heima20; import java.util.ArrayList; import java.util.HashMap; import java.util.Set; public class HashMapIncludeArrayListDemo { public static void main(String[] args) { //创建HashMap集合 HashMap<String, ArrayList<String>> hm = new HashMap<String, ArrayList<String>>(); //创建ArrayLIst集合，并添加元素 ArrayList<String> array1 = new ArrayList<String>(); array1.add("jia"); array1.add("yi"); //把ArrayList作为元素添加到HashMap集合 hm.put("sgyy", array1); ArrayList<String> array2 = new ArrayList<String>(); array2.add("bing"); array2.add("ding"); //把ArrayList作为元素添加到HashMap集合 hm.put("xiyouji", array2); ArrayList<String> array3 = new ArrayList<String>(); array3.add("wu"); array3.add("ji"); //把ArrayList作为元素添加到HashMap集合 hm.put("honglou", array3); //遍历HashMap集合 Set<String> keySet = hm.keySet(); for (String key : keySet) { System.out.println(key); ArrayList<String> value = hm.get(key); for (String s : value) { System.out.println("\t" + s); } } } }案例：统计字符串中每个字符出现的次数
需求：键盘录入一个字符串，要求同级灭个字符串出现的次数。
举例：键盘录入“aababcabcdabcde” 在控制台输出“a(5)b(4)c(3)d(2)e(1)"
分析：
-
我们可以把结果分成几个部分来看：a(5),b(4),c(3),d(2),e(1)
-
每一个部分可以给看成是：字符和字符对应的次数组成
-
这样的数据，我们可以通过HashMap集合来存储，键是字符，值是字符出现的次数
注意：键是字符，类型应该是Character；值是字符出现的次数，类型应该是Integer
思路：
-
键盘录入一个字符串
-
创建HashMap集合，键是Character，值是Integer
-
遍历字符串，得到每一个字符
-
用得到的每一个字符作为键到HashMap集合中去找对应的值，看起返回值
如果返回值是null：说明该字符在HashMap集合中不存在，就把改字符作为键，１作为值存储
如果返回值不是null:说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值
-
遍历HashMap集合，得到键和值，按要求进行拼接
-
输出结果
package heima21; import java.util.HashMap; import java.util.Scanner; import java.util.Set; import java.util.TreeMap; public class HashMapDemo { public static void main(String[] args) { //键盘录入一个字符串 Scanner sc = new Scanner(System.in); System.out.println("请输入一个字符串"); String line = sc.nextLine(); //创建HashMap集合，键是Character，值是Integer // HashMap<Character, Integer> hm = new HashMap<Character, Integer>();//HashMap不对键进行排序 TreeMap<Character,Integer> hm=new TreeMap<Character,Integer>();//TreeMap对键进行排序，用法与HashMap一样 //遍历字符串，得到每一个字符 for (int i = 0; i < line.length(); i++) { char key = line.charAt(i); //拿得到的每一个字符串作为键到HashMap集合中去找对应的值，看其返回值 Integer value = hm.get(key); if (value == null) { //如果返回值是null，说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储 hm.put(key, 1); } else { //如果返回值不是null，说明该字符在HashMap集合中存在，把该值加1，然后重新存储该字符和对应的值 value++; hm.put(key, value); } } //遍历HashMap集合，得到键和值，按照要求进行拼接 StringBuilder sb = new StringBuilder(); Set<Character> keySet = hm.keySet(); for (Character key : keySet) { Integer value = hm.get(key); sb.append(key).append("(").append(value).append(")"); } String result = sb.toString(); //输出结果 System.out.println(result); } }
-
-
Collections
-
Collections概述和使用
Collections类的概述
- 是针对集合操作的工具类
Collections类的常用方法
- public static <T extends Comparable<? super T>> void sort(List list):将指定的列表按升序排序
- public static void reverse(List<?> list):反转指定裂变中元素的顺序
- public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表
package heima22; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.List; public class CollectionsDemo { public static void main(String[] args) { //创建集合对象 List<Integer> list = new ArrayList<Integer>(); //添加元素 list.add(30); list.add(20); list.add(80); list.add(40); System.out.println(list); //public static <T extends Comparable<? super T>> void sort(List <T> list):将指定的列表按升序排序 Collections.sort(list); //public static void reverse(List<?> list):反转指定裂变中元素的顺序 Collections.reverse(list); //public static void shuffle(List<?> list):使用默认的随机源随机排列指定的列表 Collections.shuffle(list);//每一个出现的顺序都是随机的，模拟洗牌的动作 System.out.println(list); } }案例：ArrayList存储学生对象并排序
需求：ArrayList存储学生对象，使用Collection对ArrayLIst进行排序
按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
思路：
- 定义学生类
- 创建ArrayList集合对象
- 创建学生对象
- 把学生添加到集合
- 使用Collections对ArrayList集合排序
- 遍历集合
package heima23; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.Comparator; public class CollectionDemo01 { public static void main(String[] args) { //创建ArrayList集合对象 ArrayList<Student> array = new ArrayList<Student>(); //创建学生对象 Student s1 = new Student("zhangsan", 20); Student s2 = new Student("lisi", 21); Student s3 = new Student("wangwu", 22); Student s4 = new Student("liuliu", 23); //把学生添加到集合 array.add(s1); array.add(s2); array.add(s3); array.add(s4); //使用Collections对ArrayList集合排序 //sort(List<T> list,Comparator<? super T> c) // Collections.sort(array);//学生类没有实现自然排序接口，所有报错；使用另一种方法，根据指定的比较器引起的顺序对指定的裂变进行排序 Collections.sort(array, new Comparator<Student>() { @Override public int compare(Student s1, Student s2) { //按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序 int num = s1.getAge() - s2.getAge(); int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return num2; } }); //遍历集合 for (Student s : array) { System.out.println(s.getName() + "," + s.getAge()); } } }案例：模拟斗地主
需求：通过程序实现斗地主过程中的洗牌，发牌和看牌
思路：
- 创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现
- 往牌盒里面装牌
- 洗牌，也就是把牌打散，用Collections的shuffle()方法实现
- 发牌，也就是遍历集合，给三个玩家发牌
- 看牌，也就是三个玩家分别遍历自己的牌
package heima24; import java.util.ArrayList; import java.util.Collection; import java.util.Collections; public class PokerDemo { public static void main(String[] args) { //创建一个牌盒，也就是定义一个集合对象，用ArrayList集合实现 ArrayList<String> array = new ArrayList<String>(); //往牌盒里面装牌 /* ♦2，♦3，♦4，....，♦k,♦A ♣2，... ♥2，... ♠2，... 小王，大王 */ //定义花色数组 String[] colors = {"♦", "♣", "♥", "♠"}; //定义点数数组 String[] numbers = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"}; for (String color : colors) { for (String number : numbers) { array.add(color + number); } } array.add("小王"); array.add("大王");//此时牌盒中有牌了 //洗牌，也就是把牌打散，用Collections的shuffle()方法实现 Collections.shuffle(array); //发牌，也就是遍历集合，给三个玩家发牌 ArrayList<String> lqxArray = new ArrayList<String>();//1号玩家 ArrayList<String> lyArray = new ArrayList<String>();//2号玩家 ArrayList<String> fqyArray = new ArrayList<String>();//3号玩家 ArrayList<String> dpArray = new ArrayList<String>();//底牌 for (int i = 0; i < array.size(); i++) { String poker = array.get(i); if (i >= array.size() - 3) { dpArray.add(poker); } else if (i % 3 == 0) { lqxArray.add(poker); } else if (i % 3 == 1) { lyArray.add(poker); } else if (i % 3 == 2) { fqyArray.add(poker); } } //看牌，也就是三个玩家分别遍历自己的牌 lookpoker("lqx", lqxArray); lookpoker("ly", lyArray); lookpoker("fqy", fqyArray); lookpoker("dp", dpArray); } //看牌的方法 public static void lookpoker(String name, ArrayList<String> array) { System.out.println(name + "的牌是："); for (String poker : array) { System.out.println(poker + " "); } System.out.println(); } }
案例：模拟斗地主升级版
需求：通过程序实现斗地主过程中的洗牌，发牌和看牌。
要求：对牌进行排序
思路：
- 创建HashMap，键是编号，值是牌
- 创建ArrayList，存储编号
- 创建花色数组和点数数组
- 从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
- 洗牌(洗的是编号)，用Collections的shuffle()方法实现
- 发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收）
- 定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
- 调用看牌方法
package heima24; import java.util.*; public class PokerDemo { public static void main(String[] args) { //创建HashMap，键是百脑汇，值是牌 HashMap<Integer, String> hm = new HashMap<Integer, String>(); //创建ArrayList，存储编号 ArrayList<Integer> array = new ArrayList<Integer>(); //往牌盒里面装牌 /* ♦2，♦3，♦4，....，♦k,♦A ♣2，... ♥2，... ♠2，... 小王，大王 */ //定义花色数组 String[] colors = {"♦", "♣", "♥", "♠"}; //定义点数数组 String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"}; //从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号 int index = 0; for (String number : numbers) { for (String color : colors) { hm.put(index, color + number); array.add(index); index++; } } hm.put(index, "小王"); array.add(index); index++; hm.put(index, "大王")； array.add(index); //洗牌(洗的是编号)，用Collections的shuffle()方法实现 Collections.shuffle(array); //发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收） TreeSet<Integer> lqxSet = new TreeSet<Integer>(); TreeSet<Integer> lySet = new TreeSet<Integer>(); TreeSet<Integer> fqySet = new TreeSet<Integer>(); TreeSet<Integer> dpSet = new TreeSet<Integer>(); for (int i = 0; i < array.size(); i++) { int x = array.get(i); if (i >= array.size() - 3) { dpSet.add(x); } else if (i % 3 == 0) { lqxSet.add(x); } else if (i % 3 == 1) { lqxSet.add(x); } else if (i % 3 == 2) { fqySet.add(x); } } //调用看牌方法 lookpoker("lqx", lqxSet, hm); lookpoker("ly", lySet, hm); lookpoker("fqy", fqySet, hm); lookpoker("dp", dpSet, hm); } //定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌) public static void lookpoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) { System.out.println(name + "的牌是："); for (Integer key : ts) { String poker = hm.get(key); System.out.println(poker + " "); } System.out.println(); } } -
//创建ArrayList，存储编号
ArrayList array = new ArrayList();
//往牌盒里面装牌
/*
♦2，♦3，♦4，....，♦k,♦A
♣2，...
♥2，...
♠2，...
小王，大王
*/
//定义花色数组
String[] colors = {"♦", "♣", "♥", "♠"};
//定义点数数组
String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
//从0开始往HashMap里面存储编号，并存储对应的牌。同时往ArrayList里面存储编号
int index = 0;
for (String number : numbers) {
for (String color : colors) {
hm.put(index, color + number);
array.add(index);
index++;
}
}
hm.put(index, "小王");
array.add(index);
index++;
hm.put(index, "大王")；
array.add(index);
//洗牌(洗的是编号)，用Collections的shuffle()方法实现
Collections.shuffle(array);
//发牌(发的也是编号，为了保证编号是排序的，创建TreeSet集合接收）
TreeSet<Integer> lqxSet = new TreeSet<Integer>();
TreeSet<Integer> lySet = new TreeSet<Integer>();
TreeSet<Integer> fqySet = new TreeSet<Integer>();
TreeSet<Integer> dpSet = new TreeSet<Integer>();
for (int i = 0; i < array.size(); i++) {
int x = array.get(i);
if (i >= array.size() - 3) {
dpSet.add(x);
} else if (i % 3 == 0) {
lqxSet.add(x);
} else if (i % 3 == 1) {
lqxSet.add(x);
} else if (i % 3 == 2) {
fqySet.add(x);
}
}
//调用看牌方法
lookpoker("lqx", lqxSet, hm);
lookpoker("ly", lySet, hm);
lookpoker("fqy", fqySet, hm);
lookpoker("dp", dpSet, hm);
}
//定义方法看牌(遍历TreeSet集合，获取编号，到HashMap集合找对应的牌)
public static void lookpoker(String name, TreeSet<Integer> ts, HashMap<Integer, String> hm) {
System.out.println(name + "的牌是：");
for (Integer key : ts) {
String poker = hm.get(key);
System.out.println(poker + " ");
}
System.out.println();
}
}
3357
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
