集合
集合类的特点：提供一种存储空间可变的存储模型，存储的数据容量可以随时发生改变。
1. Collection(接口)：单列集合List(接口)：元素可重复ArrayList(实现类)：LinkedList(实现类)：Set(接口)：元素不可重复HashSet(实现类)：TreeSet(实现类)：2. Map(接口)：双列集合HashMap(实现类)：Collection集合
1. Collection是单列集合的顶层接口。2. Collection没有任何具体的实现类，创建对象时必须使用子类接口List或Set的实现类。创建Collection集合对象的方式
- 多态的方式
- 具体的实现类，如ArrayList
public class CollectionDemo { public static void main(String[] args) { //创建Collection对象 Collection cc = new ArrayList(); //添加元素 String类型 cc.add("茶碗儿"); cc.add("雀巢咖啡"); //运行结果：[茶碗儿, 雀巢咖啡] //说明重写了toString()方法 System.out.println(cc); }}Collection集合的常用方法
- boolean add()添加元素
- boolean remove()移除指定元素
- void clear()清空集合
- boolean contains()判断集合是否包含指定元素
- isEmpty()判断集合是否为空
- int size()获取集合的长度
Collection集合的遍历
- iterator：迭代器，集合的专用遍历方式。iterator()返回集合中的迭代器。
- 迭代器中的方法
- E next()返回迭代中的下一个元素。也就是获取元素的。
- boolean hasNext() 如果迭代中具有更多元素，返回true。也就是用来判断元素是否存在。
//Collection集合的遍历public class CollectionDemo { public static void main(String[] args) { Collection cc = new ArrayList(); cc.add("茶碗儿"); cc.add("雀巢咖啡"); cc.add("五香卤蛋"); Iterator it = cc.iterator(); //先判断元素是否存在，再获取元素 while (it.hasNext()){ String s = it.next(); System.out.println(s); } }}运行结果：
茶碗儿雀巢咖啡五香卤蛋练习：创建Collection集合，添加三个学生对象，遍历
//学生类public class Student { private String Name; private int age; public Student() { } public Student(String name, int age) { Name = name; this.age = age; } public String getName() { return Name; } public void setName(String name) { Name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }//重写toString() @Override public String toString() { return "Student{" + "Name='" + Name + '\'' + ", age=" + age + '}'; }}//测试类public class StudentDemo { public static void main(String[] args) { //创建Collection集合，类型为学生类 Collection co = new ArrayList(); //创建学生对象 Student s1 = new Student("茶碗儿", 11); Student s2 = new Student("花生糖", 12); Student s3 = new Student("燕麦片", 13); //向集合中添加元素 co.add(s1); co.add(s2); co.add(s3); //获取集合中的迭代器 Iterator it = co.iterator(); //遍历集合 while (it.hasNext()){ System.out.println(it.next()); } }}//运行结果Student{Name='茶碗儿', age=11}Student{Name='花生糖', age=12}Student{Name='燕麦片', age=13}List集合
特点
- List集合：有序集合，有索引，元素可重复
- 可精确控制元素的插入位置，可通过索引访问指定元素
总结
- 有序：存储和取出的元素顺序一致
- 可重复：存储的元素可重复
List集合特有方法
- void add(int index,E element)在集合中指定位置，插入指定的元素。
- E remove(int index)删除指定索引处的元素，返回被删除的元素。
- E set(int index,E element)修改指定索引处的元素，返回被修改的元素。
- E get(int index)返回指定索引处的元素。
//遍历List集合public class ListDemo { public static void main(String[] args) { List list = new ArrayList(); list.add("hello"); list.add("java"); list.add("world"); for (String s : list) { System.out.println(s); } }}//运行结果hellojavaworld并发修改异常 ConcurrentModificationException
案例：
//判断集合里是否有元素"world"，如果有，则像集合中添加元素"javaee"public class ListDemo2 { public static void main(String[] args) { List list = new ArrayList(); list.add("hello"); list.add("java"); list.add("world"); Iterator it = list.iterator(); while(it.hasNext()){ String s = it.next(); if (s.equals("world")){ //通过集合对象，向集合中添加元素 list.add("javaee"); } } System.out.println(list); }}运行结果
//并发修改异常 ConcurrentModificationExceptionException in thread "main" java.util.ConcurrentModificationExceptionat java.base/java.util.ArrayList$Itr.checkForComodification(ArrayList.java:1013)at java.base/java.util.ArrayList$Itr.next(ArrayList.java:967)at com.chawaner.test4.ListDemo2.main(ListDemo2.java:25)并发修改异常产生的原因：
迭代器通过next()方法获取元素时会判断预期修改值和实际修改值是否相等。迭代器遍历元素过程中，如果集合对象通过add()方法修改了集合中的元素，就会导致预期修改值和实际修改值不一致。
解决方案
如果需要在遍历操作中插入元素，使用for循环遍历（普通for循环，不是迭代器for），然后用集合对象操作即可。
解决方案：
public class ListDemo2 { public static void main(String[] args) { List list = new ArrayList(); list.add("hello"); list.add("java"); list.add("world");//增强for，其实就是迭代器遍历，会出现并发修改异常 //for (String s : list) { // if (s.equals("world")){ // list.add("javaee"); // } //}//使用for循环解决并发修改异常 for (int i = 0; i < list.size(); i++) { String s = list.get(i); if (s.equals("world")){ list.add("javaee"); } } System.out.println(list); }}运行结果：
[hello, java, world, javaee]列表迭代器
public static void main(String[] args) { List list = new ArrayList(); list.add("hello"); list.add("world"); list.add("java"); //获取列表迭代器 listIterator() ListIterator it = list.listIterator(); //遍历 System.out.println("遍历集合："); //判断下一个元素是否存在 hasNext() while (it.hasNext()){ //获取下一个元素 next() System.out.println(it.next()); } //逆向遍历 System.out.println("逆向遍历集合："); //判断前一个元素是否存在 hasPrevious() while (it.hasPrevious()){ //获取前一个元素 previous() System.out.println(it.previous()); } //遍历时向集合中插入元素 while (it.hasNext()){ String s = it.next(); if (s.equals("world")){ /*通过列表迭代器，将指定的的元素插入集合； 迭代器中没有add()方法，而列表迭代器中有add()方法； 列表迭代器中的add()方法会把实际修改值赋值给预期修改值； next()方法获取元素时判断预期修改值和实际修改值是否相等，就不会出现并发修改异常。 */ it.add("吃饭"); } System.out.println(list); }}增强for循环
增强for简化了数组和集合的遍历
- JDK5之后出现，内部原理是包装了一个Iterator迭代器
案例：
public static void main(String[] args) { int[] arr = {15, 45, 56, 98, 32}; //数组遍历 for (int i : arr) { System.out.println(i); } System.out.println("---------------"); List list = new ArrayList(); list.add("黑化肥发黑会挥发"); list.add("喝咖啡就大蒜"); list.add("鸡你太美接化发"); //集合遍历 for (String s : list) { System.out.println(s); }}运行结果：
1545569832---------------黑化肥发黑会挥发喝咖啡就大蒜鸡你太美接化发List集合存储对象的三种遍历方式
- 普通for循环遍历：带有索引的遍历方式
- 迭代器遍历：集合特有的遍历方式
- 增强for遍历：最方便的遍历方式
常见的数据结构
- 栈：先进后出（水桶）
- 队列：先进先出（管道）
- 数组：查询快，增删慢
- 查询元素通过索引定位，查询任意元素耗时相同，查询速度快
- 删除数据时，要将原始将元素删除，同时后面每个元素要前移，删除效率低
- 添加数据时，先所有元素后移一位，才能在指定位置添加元素，添加效率极低
- 链表：增删快，查询慢（都是相比数组而言）
- 链表元素被称为结点
- 结点有地址（存储位置），地址里面有数据和下一个结点的地址
- ^：结点指向空地址，表示结束
- 添加：添加到指定位置，更改前一个结点的指向，更改要添加的结点的指向到后面的节点
- 删除：更改前一个结点的指向，再删除指定结点
- 查询：从头开始查询，查询速度慢
- 哈希表：
- JDK8之前，底层采用数组+链表，即元素为链表的数组结构
- JDK8之后，在长度比较长的时候，底层实现了优化（略）
List集合子类特点：使用的时候，要考虑场景是查询还是增删
- List集合常用子类：ArrayList，LinkedList
- ArrayList：底层数据结构是数组（查询快，增删慢）
- LinkedList：底层数据结构是链表（查询慢，增删快）
基本使用案例：
public static void main(String[] args) { //ArrayList添加元素 List arr = new ArrayList(); arr.add("鸡你太美"); arr.add("接化发"); arr.add("耗子尾汁"); ListIterator ait = arr.listIterator(); //列表迭代器遍历查询，并添加元素 while (ait.hasNext()) { String s = ait.next(); if (s.equals("接化发")) { ait.add("偷袭"); } } //增强for遍历ArrayList集合 for (String s : arr) { System.out.println(s); } System.out.println("-----------------"); //LinkedList添加对象 List lin = new LinkedList(); Student s1 = new Student("曹操", 11); Student s2 = new Student("刘备", 12); Student s3 = new Student("孙权", 13); lin.add(s1); lin.add(s2); lin.add(s3); //增强for遍历集合 for (Student student : lin) { System.out.println(student); }}运行结果：
鸡你太美接化发偷袭耗子尾汁-----------------Student{Name='曹操', age=11}Student{Name='刘备', age=12}Student{Name='孙权', age=13}LinkedList特有的方法
public static void main(String[] args) { //创建一个LinkedList LinkedList list = new LinkedList(); //添加元素 list.add("鸡你太美"); list.add("接化发"); list.add("混元形意太极门"); list.add("耗子尾汁"); //输出集合 System.out.println("列表："+list); //在列表开头插入指定元素 public void addFirst() list.addFirst("所有人下来做核酸"); //在列表末尾添加元素 public void addLast() list.addLast("叮咚鸡"); System.out.println("首尾插入元素后的列表："+list); //返回列表中的第一个元素 public E getFirst() System.out.println("返回列表第一个元素："+list.getFirst()); //返回列表中的最后一个元素 public E getLast() System.out.println("返回列表最后一个元素："+list.getLast()); //移除并返回列表第一个元素 public E removeFirst() System.out.println("移除并返回列表第一个元素："+list.removeFirst()); //移除并返回列表最后一个元素 public E removeLast() System.out.println("移除并返回列表最后一个元素："+list.removeLast()); System.out.println("移除首尾元素后的列表："+list);}运行结果：
列表：[鸡你太美, 接化发, 混元形意太极门, 耗子尾汁]首尾插入元素后的列表：[所有人下来做核酸, 鸡你太美, 接化发, 混元形意太极门, 耗子尾汁, 叮咚鸡]返回列表第一个元素：所有人下来做核酸返回列表最后一个元素：叮咚鸡移除并返回列表第一个元素：所有人下来做核酸移除并返回列表最后一个元素：叮咚鸡移除首尾元素后的列表：[鸡你太美, 接化发, 混元形意太极门, 耗子尾汁]Set集合
- 不允许元素重复
- 没有带索引的方法，不能使用普通for循环遍历
HashSet：对集合的迭代顺序不做任何保证。就是说遍历是乱序的。
public static void main(String[] args) { //Set集合存储字符串并遍历 Set set = new HashSet(); set.add("混元形意太极门"); set.add("马保国"); set.add("马保国"); set.add("接化发"); //HashSet遍历不保证顺序 for (String s : set) { System.out.println(s); }}运行结果：Set集合不包含重复的元素
接化发马保国混元形意太极门哈希值
- 哈希值：是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值。
- Object类中有一个hashCode()方法可以获取对象的哈希值。
public class HashCodeDemo { public static void main(String[] args) { Student s = new Student("马保国", 69); //Object类中有一个hashCode()方法可以获取对象的哈希值 //返回一个int类型的哈希码值 System.out.println("马保国哈希值："+s.hashCode()); System.out.println("马保国哈希值："+s.hashCode()); Student s1 = new Student("挖掘机", 25); System.out.println("挖掘机哈希值："+s1.hashCode()); }}运行结果：
马保国哈希值：189568618马保国哈希值：189568618挖掘机哈希值：666641942
- 默认使用Object类下的hashCode()方法下，同一个对象的哈希值相同，不同对象的哈希值不同。
- 重写hashCode()方法，可以使不同对象哈希值相同。
- 字符串String重写了hashCode()方法，两个不同字符串对象的哈希码值有可能相同。
//这俩字符串对象的哈希值都是：1179395System.out.println("重地".hashCode());System.out.println("通话".hashCode());HashSet集合
HashSet集合的特点
- 底层数据结构是哈希表
- 对集合迭代顺序不保证，不保证存储和取出的元素顺序一致
- 没有带索引的方法，不能使用普通for循环遍历
- 不包含重复的元素
HashSet集合添加一个元素的过程
- 调用对象的hashCode()获取对象的哈希值
- 根据哈希值计算对象的存储位置
- 判断该位置是否有元素存在
- 如果没有，将元素存放到该位置
- 如果有，遍历该位置元素比较哈希值
如果哈希值不相同，存储元素到该位置
如果哈希值相同，调用equals()比较对象内容
如果内容也相同，不保存该元素
如果内容不相同，存储元素到该位置
总结：
HashSet集合添加一个元素的过程，首先要比较哈希值是否相同，哈希值不相同则保存元素；哈希值相同时，还要比较元素的内容是否相同，元素的内容不相同时才保存元素。
HashSet集合保证元素唯一性
- 要保证元素唯一性，需要重写hashCode()和equals()
哈希表
- 元素为链表的数组，默认长度为16（0-15）。
- 存储元素的时候，用元素的哈希值对16取余（%16），余数是几，就将元素存储在几的位置（每个位置都是一个链表）。
- 元素存进某个位置里的链表中，要对比这个位置里的链表中的元素的哈希值和内容（即：遵循HashSet集合的元素唯一性）。
案例
public class HashCodeDemo1 { public static void main(String[] args) { HashSet hs = new HashSet(); Student s1 = new Student("曹操", 11); Student s2 = new Student("刘备", 12); Student s3 = new Student("孙权", 13); Student s4 = new Student("孙权", 13); hs.add(s1); hs.add(s2); hs.add(s3); hs.add(s4); for (Student h : hs) { System.out.println(h); } }}运行结果
Student{Name='孙权', age=13}Student{Name='刘备', age=12}Student{Name='曹操', age=11}Student{Name='孙权', age=13}这块添加重复元素成功了，说明不是同一个对象。如果不保存重复元素，需要重写Student类里面的hashCode()和equals()。如下：
public class Student { private String Name; private int age; public Student() { } public Student(String name, int age) { Name = name; this.age = age; } public String getName() { return Name; } public void setName(String name) { Name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }//重写toString方法 @Override public String toString() { return "Student{" + "Name='" + Name + '\'' + ", age=" + age + '}'; }//重写equals方法 @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; }//重写hashCode方法 @Override public int hashCode() { int result = Name != null ? Name.hashCode() : 0; result = 31 * result + age; return result; }}再看运行结果：这下就没有重复元素了
Student{Name='孙权', age=13}Student{Name='刘备', age=12}Student{Name='曹操', age=11}LinkedHashSet集合
特点：有序，元素不重复
- 哈希表和链表实现的Set接口，具有可预测的迭代次序
- 由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
- 由哈希表保证元素唯一，也就是说没有重复元素
案例：LinkedHashSet集合存储字符串并遍历
public class HashCodeDemo1 { public static void main(String[] args) { LinkedHashSet lhs = new LinkedHashSet(); lhs.add("春天"); lhs.add("夏天"); lhs.add("夏天"); lhs.add("秋天"); lhs.add("冬天"); for (String lh : lhs) { System.out.println(lh); } }}运行结果：有序，元素不重复
春天夏天秋天冬天TreeSet集合
特点
- 元素有序，指的不是存取的顺序，而是按照某种规则进行排序，排序方式取决于构造方法。
- TreeSet()：根据元素的自然排序进行排序
- TreeSet(Comparator comparator)：根据指定的比较器进行排序
- 没有带索引的方法，不能使用普通for循环遍历。
- 由于是Set集合，所以元素不重复。
案例：TreeSet集合存储整数并遍历
public class TreeSetDemo { public static void main(String[] args) { TreeSet ts = new TreeSet(); ts.add(10); ts.add(30); ts.add(20); ts.add(20); ts.add(50); ts.add(40); for (Integer t : ts) { System.out.println(t); } }}运行结果：自然排序（从小到大），元素不重复
1020304050自然排序Comparable
案例：
public class ComparableDemo { public static void main(String[] args) { /*存储学生对象并遍历，创建TreeSet集合使用无参构造方法 * 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序*/ TreeSet ts = new TreeSet(); Student s1 = new Student(); s1.setName("Tom"); s1.setAge(11); Student s2 = new Student(); s2.setName("Carl"); s2.setAge(12); Student s3 = new Student(); s3.setName("Bob"); s3.setAge(13); Student s4 = new Student(); s4.setName("iKun"); s4.setAge(12); ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); for (Student t : ts) { System.out.println(t); } }}运行结果：类型转换异常，要实现自然排序，Student类要实现Comparable接口并重写compareTo()
Exception in thread "main" java.lang.ClassCastException: class com.chawaner.test5.Student cannot be cast to class java.lang.Comparable (com.chawaner.test5.Student is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap')at java.base/java.util.TreeMap.compare(TreeMap.java:1291)at java.base/java.util.TreeMap.put(TreeMap.java:536)at java.base/java.util.TreeSet.add(TreeSet.java:255)at com.chawaner.test5.ComparableDemo.main(ComparableDemo.java:29)修改Student类：
public class Student implements Comparable{ private String Name; private int age; public Student() { } public Student(String name, int age) { Name = name; this.age = age; } public String getName() { return Name; } public void setName(String name) { Name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; }//重写toString @Override public String toString() { return "Student{" + "Name='" + Name + '\'' + ", age=" + age + '}'; }//重写equals @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; }//重写hashCode @Override public int hashCode() { int result = Name != null ? Name.hashCode() : 0; result = 31 * result + age; return result; } //重写compareTo @Override public int compareTo(Student o) { //返回0，表示添加的第二个元素跟第一个元素是同一个元素,所以只会添加第一个元素成功 return 0; }}运行结果：只会添加第一个元素成功
Student{Name='Tom', age=11}如果将compareTo方法里面的返回值改为1，则会认为第二个元素比第一个元素大，第二个元素就会添加到第二个元素后面。遍历时，就是按照元素的添加顺序输出结果
//重写compareTo@Overridepublic int compareTo(Student o) {//返回0，表示添加的第二个元素跟第一个元素是同一个元素,所以只会添加第一个元素成功.//返回1，则会认为第二个元素比第一个元素大，第二个元素就会添加到第二个元素后面。遍历时，就是按照元素的添加顺序输出结果。同理，返回-1则会按照倒序添加元素成功。 return 1;}运行结果：添加元素成功
Student{Name='Tom', age=11}Student{Name='Carl', age=12}Student{Name='Bob', age=13}Student{Name='iKun', age=12}修改compareTo()，按照年龄排序
//重写compareTo,按照年龄排序@Overridepublic int compareTo(Student o) {//从小到大排序 //当前要存储的元素 this.age,上一个元素 o.age int num = this.age - o.age; //从大到小排序 //int num = o.age - this.age; return num;}运行结果：年龄从小到大排序，但是年龄相同的元素值保存成功了第一个
Student{Name='Tom', age=11}Student{Name='Carl', age=12}Student{Name='Bob', age=13}修改compareTo()，按照年龄从小到大排序，年龄相同时，按照姓名首字母排序
@Overridepublic int compareTo(Student o) { //按照年龄规则，从小到大排序 //当前要存储的元素 this.age,上一个元素 o.age int num = this.age - o.age; //从大到小排序 //int num = o.age - this.age; //年龄相同时，按照姓名首字母顺序排序 //Name是个字符串，String实现了Comparable，所以能直接调用compareTo(T o)实现自然排序 //三目运算，当年龄相同，按照姓名自然排序，否则按照年龄规则排序 int num2 = num == 0 ? this.Name.compareTo(o.Name) : num; return num2;}运行结果：年龄从小到大排序，年龄相同时，按照姓名首字母顺序排序
Student{Name='Tom', age=11}Student{Name='Carl', age=12}Student{Name='iKun', age=12}Student{Name='Bob', age=13}再测一下姓名和年龄都相同时，能否保证元素的唯一性
public class ComparableDemo { public static void main(String[] args) { /*存储学生对象并遍历，创建TreeSet集合使用无参构造方法 * 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序*/ TreeSet ts = new TreeSet();Student s1 = new Student(); s1.setName("Tom"); s1.setAge(11); Student s2 = new Student(); s2.setName("Carl"); s2.setAge(12); Student s3 = new Student(); s3.setName("Bob"); s3.setAge(13); Student s4 = new Student(); s4.setName("iKun"); s4.setAge(12); Student s5 = new Student(); s5.setName("Bob"); s5.setAge(13); ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); for (Student t : ts) { System.out.println(t); } }}运行结果：姓名和年龄都相同时，保证了元素的唯一性
Student{Name='Tom', age=11}Student{Name='Carl', age=12}Student{Name='iKun', age=12}Student{Name='Bob', age=13}TreeSet集合总结
- 能够按照规则排序，并且能对元素去重
- 重写compareTo方法时，要注意排序规则，按照要求的主要条件（num）和次要条件（num2）来写
比较器排序Comparator
要求：存储学生对象并遍历，创建TreeSet集合，使用带参构造方法创建学生对象
- 使用比较器Comparator按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
public class ComparatorDemo { public static void main(String[] args) { //TreeSet里面有一个Comparator接口，实际用的是Comparator的实现类对象 //这里使用匿名内部类的方法,使用比较器Comparator来实现排序 TreeSet ts = new TreeSet(new Comparator() { @Override public int compare(Student s1, Student s2) { //按照年龄规则排序 //现在是在测试类里面，所以不能直接访问Student类的成员变量age，得用getAge() int num = s1.getAge() - s2.getAge(); //按照年龄规则排序，年龄相同时，按照姓名自然排序 int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return num2; } }); //使用带参构造方法创建元素 Student s1 = new Student("Tom",11); Student s2 = new Student("Carl",12); Student s3 = new Student("Bob",13); Student s4 = new Student("iKun",12); Student s5 = new Student("Bob",13); //添加元素到TreeSet集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //增强for遍历集合 for (Student t : ts) { System.out.println(t); } }}运行结果：
Student{Name='Tom', age=11}Student{Name='Carl', age=12}Student{Name='iKun', age=12}Student{Name='Bob', age=13}结论：
- 自然排序：是在学生类里面，重写compareTo(T o)，自定义排序规则
- 比较器排序，是在测试类里面，让集合接收一个Comparator接口的实现类对象，重写compare(T o1,T o2)方法
- 重写方法时，一定要按照 要求的主要条件（num）和次要条件（num2）来写
泛型
- 泛型
- 本质是参数化类型
- 将类型由原来具体的参数化，在使用/调用时传入具体的类型
- 泛型的好处
- 把运行时期遇到的问题提前到了编译时期
- 避免了强制类型转换
泛型类
案例：
//定义一个泛型类，生成set/get方法public class Generic { private T t; public T getT() { return t; } public void setT(T t) { this.t = t; }}//测试类public class GenericDemo { public static void main(String[] args) { //根据泛型创建对象 Generic g1 = new Generic(); //根据泛型设置信息 g1.setT("小明"); System.out.println(g1.getT()); Generic g2 = new Generic(); g2.setT(12); System.out.println(g2.getT()); }}运行结果：泛型类可以定义任何类型
小明12泛型方法
案例：
//泛型类public class Generic { /** * 返回类型为传入参数的类型 * @param t * @param */ public void show(T t) { System.out.println(t); }}//测试类public class GenericDemo { public static void main(String[] args) { //根据传入的参数类型，返回相同类型的返回值 Generic g = new Generic(); g.show("小明"); g.show(12); g.show(true); }}运行结果：
小明12true泛型接口
//定义一个泛型接口public interface Generic { void show(T t);}//定义一个泛型接口的实现类public class GenericImpl implements Generic{ @Override public void show(T t) { System.out.println(t); }}//测试类public class GenericDemo { public static void main(String[] args) { Generic g1 = new GenericImpl(); g1.show("小明"); Generic g2 = new GenericImpl(); g2.show(32); }}运行结果：
小明32类型通配符
类型通配符：表示任意类型
类型通配符的上限：表示的类型是当前类型或者其子类
类型通配符的下限：表示的类型是当前类型或者其父类
public class GenericDemo { public static void main(String[] args) { //类型通配符 表示任意类型 List l1 = new ArrayList可变参数
修饰符返回值类型方法名(数据类型…变量名){}
如：public static int sum(int…a){}
public class GenericDemo1 { public static void main(String[] args) { //调用可变参数方法求和 System.out.println(sum(10)); System.out.println(sum(10, 20)); System.out.println(sum(10, 20, 30)); } /** * 可变参数求和 * @param a 其实是个数组 * @return 求和结果 * 如果除了可变参数以外还有别的参数，要将可变参数放在后面 * 如：public static int sum(int b,int...a){} */ public static int sum(int...a){ //定义sum并初始化 int sum = 0; //遍历数组元素，求和 for (int i : a) { sum += i; } return sum; }}运行结果：
103060
- Arrays工具类中有一个静态方法：
- public static List asList(T… a)：返回由指定数组支持的固定大小的列表
- 返回的集合不能做增删操作，可以做修改操作
- List接口中有一个静态方法：
- public static List of(E… elements)：返回包含任意数量元素的不可变列表
- 返回的集合不能做增删改操作
- Set接口中有一个静态方法：
- public static Set of(E… elements) ：返回一个包含任意数量元素的不可变集合
- 在给元素的时候，不能给重复的元素
- 返回的集合不能做增删操作，没有修改的方法
Map集合
- public interface Map
- K：键的类型，V：值的类型
- 将键映射到值的对象。不能包含重复的键；每个键只能映射到一个值。
public class MapDemo { public static void main(String[] args) { //多态的方式创建Map集合 //具体的实现类HashMap Map m = new HashMap(); m.put("001","小红"); m.put("002","小明"); m.put("002","小军"); m.put("004","小刚"); System.out.println(m); }}运行结果：键不能重复。键相同的情况下，后面的元素会覆盖前面的元素。
//HashMap集合重写了toString(){001=小红, 002=小军, 004=小刚}Map集合的常用方法
public class MapDemo { public static void main(String[] args) { Map m = new HashMap(); //添加元素 m.put("001","小明"); m.put("002","小红"); m.put("003","小刚"); System.out.println(m); //集合的长度 System.out.println("集合的长度:"+m.size()); //判断集合是否为空 System.out.println("集合是否为空:"+m.isEmpty()); //根据键删除元素 m.remove("001"); System.out.println("根据键001删除元素后的集合:"+m); //判断是否包含指定的键 System.out.println("否包含键002:"+m.containsKey("002")); //判断是否包含指定的值 System.out.println("是否包含小刚:"+m.containsValue("小刚")); //删除所有元素 m.clear(); System.out.println("删除所有元素后的集合长度："+m.size()); //判断集合是否为空 System.out.println("集合是否为空:"+m.isEmpty()); }}运行结果：
{001=小明, 002=小红, 003=小刚}集合的长度:3集合是否为空:false根据键001删除元素后的集合:{002=小红, 003=小刚}否包含键002:true是否包含小刚:true删除所有元素后的集合长度：0集合是否为空:trueMap集合的获取功能
public class MapDemo { public static void main(String[] args) { //创建集合对象 Map m = new HashMap(); //添加元素 m.put("001", "小明"); m.put("002", "小红"); m.put("003", "小刚"); //输出集合 System.out.println("集合：" + m); //根据键获取值 System.out.println("根据键001获取值：" + m.get("001")); //获取所有键 System.out.println("获取所有键：" + m.keySet()); //获取所有值 System.out.println("获取所有值：" + m.values()); //获取所有键值对对象，HashMap重写了toString() System.out.println("获取所有键值对对象：" + m.entrySet()); }}运行结果：
集合：{001=小明, 002=小红, 003=小刚}根据键001获取值：小明获取所有键：[001, 002, 003]获取所有值：[小明, 小红, 小刚]//HashMap重写了toString()获取所有键值对对象：[001=小明, 002=小红, 003=小刚]Map集合的遍历
两种遍历方法
- 键找值：获取所有的键，遍历键，根据键获取对应的值
- 键值对对象找键和值：获取所有键值对对象，遍历键值对对象，根据键值对对象获取对应的键和对应的值
public class MapDemo { public static void main(String[] args) { /*获取所有的键，遍历键，根据键获取对应的值*/ //创建集合 Map m = new HashMap(); //添加元素 m.put("001", "小明"); m.put("002", "小红"); m.put("003", "小刚"); //获取所有键 Set keySet = m.keySet(); //遍历键 for (String s : keySet) { //根据键获取对应的值 System.out.println(m.get(s)); } }}运行结果：
小明小红小刚public class MapDemo { public static void main(String[] args) { /*获取所有键值对对象，遍历键值对对象，根据键值对对象获取对应的键和对应的值*/ //创建集合 Map m = new HashMap(); //添加元素 m.put("001", "小明"); m.put("002", "小红"); m.put("003", "小刚"); //获取所有键值对对象，键值对对象类型 Map.Entry Set<Map.Entry> entries = m.entrySet(); //遍历键值对对象 for (Map.Entry entry : entries) { //根据键值对对象获取对应的键和对应的值 System.out.println(entry.getKey()+"---"+entry.getValue()); } }}运行结果：
001---小明002---小红003---小刚统计字符串中每个字符串出现的次数
public class MapDemo { public static void main(String[] args) { /*统计字符串中字符出现的次数*/ //初始化字符串 String s = "aabbbcceddeccaabeed"; //创建集合 键：字符 值：次数 Map m = new HashMap(); //遍历字符串，拿到每一个字符 for (int i = 0; i < s.length(); i++) { //用拿到每一个字符作为键，到HashMap集合中去找对应的值，看返回值 char key = s.charAt(i); //该字符出现的次数 Integer value = m.get(key); //如果返回值为null,说明该字符在HashMap集合中不存在，是第一次出现，设置值为1 if (value == null){ //存储元素到HashMap集合中 HashMap m.put(key,1); }else {//如果返回值不为null,说明该字符在HashMap集合中存在，让值+1 //该字符出现的次数+1 value++; //重新存储，覆盖原有值(HashMap集合键的唯一性) m.put(key,value); } } //创建StringBuilder可变字符串 StringBuilder sb = new StringBuilder(); //遍历HashMap集合，得到键的值 //遍历所有键，通过建找到对应值 for (Character key : m.keySet()) { Integer value = m.get(key); //像字符串中添加元素 sb.append(key+"("+value+")"); } //输出结果 System.out.println("统计字符串中字符出现的次数：" + sb.toString()); }}运行结果
统计字符串中字符出现的次数：a(4)b(4)c(4)d(3)e(4)Collections工具类
Collections类是操作集合的工具类
Collections类中常用的方法
- public static void sort(List list)：将指定的列表按升序排序将指定的列表按升序排序
- public static void reverse(List list)：反转指定列表中元素的顺序
- public static void shuffle(List list)：使用默认的随机源随机排列指定的列表
public class CollectionsDemo { public static void main(String[] args) { //创建集合 ArrayList arr = new ArrayList(); //添加元素 arr.add(20); arr.add(10); arr.add(30); //输出集合 System.out.println("集合："+arr); //升序排序 Collections.sort(arr); System.out.println("升序排序："+arr); //反转顺序 Collections.reverse(arr); System.out.println("反转顺序："+arr); //随机排列 Collections.shuffle(arr); System.out.println("随机排列："+arr); }}运行结果：
集合：[20, 10, 30]升序排序：[10, 20, 30]反转顺序：[30, 20, 10]随机排列：[10, 30, 20]