Collection集合
-
单列集合的顶层接口 表示一组对象 这些对象被称为Collection的元素
-
JDK不提供此接口的任何实现 他提供更具体的子接口Set和List实现
-
创建Collection集合的对象 可通过多态的方式创建
-
常见用法:
//多态创建ArrayList集合 Collection<String> c = new ArrayList<>(); //添加元素 c.add("Hello"); c.add("world"); c.add("java"); //从集合中移除指定元素 System.out.println(c.remove("world"));//true System.out.println(c.remove("javaee"));//false 不存在javaee //清空集合中所有元素 //c.clear(); //判断集合中是否存在指定元素 System.out.println(c.contains("java"));//true System.out.println(c.contains("javaee"));//false //判断集合是否为空 System.out.println(c.isEmpty());//false 即 不为空 //集合长度 System.out.println(c.size()); System.out.println(c);
遍历方法
🐱👓Iterator 迭代器 (集合专用遍历方式)
Iterator<String> it = c.iterator();
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
//有一个学生类的情况
Iterator<Student> it = c.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
🐱🚀Listlterator列表迭代器(List集合特有)
- 允许往任一方向遍历列表的列表迭代器 在迭代期间修改列表 并获取列表中迭代器的当前位置
//创建集合对象
List<String> list = new ArrayList<>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//通过listIterator()方法得到
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);
}
System.out.println("----------------------------");
//获取列表迭代器
ListIterator<String> lit2 = list.listIterator();
while (lit2.hasNext()){
String s = lit2.next();
if(s.equals("world")){
lit2.add("javaee");
}
}
System.out.println(list);
🧑可在迭代期间修改列表
如果用普通迭代器,底层代码中有期望次数和实际次数(防止无限次迭代发生的策略)如果对值进行修改则会出现期望次数和实际次数不一样的情况会产生运行错误。
如果使用列表迭代器则无需考虑期望次数和实际次数的问题即可以实现在迭代期间修改列表
🐱👤增强for
- 简化数组和Collection集合的遍历
- 实现Iterable接口的类允许其对象成为增强for语句的目标
- 内部原理为迭代器
//int数组迭代
int[] arr = {1,2,3,4,5};
for(int i : arr){
System.out.println(i);
}
System.out.println("------------------");
//String数组迭代
String[] strArray = {"Hello", "World", "Java"};
for(String s : strArray){
System.out.println(s);
}
System.out.println("------------------");
//List集合的迭代
List<String> list = new ArrayList<>();
list.add("hello");
list.add("world");
list.add("java");
for(String s : list){
System.out.println(s);
}
🐱💻普通for(有索引)
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
System.out.println(s);
}
Collections类
-
针对集合操作的工具类
-
常见用法:
List<Integer> list = new ArrayList<>(); list.add(30); list.add(20); list.add(50); list.add(10); list.add(40); //升序排序 Collections.sort(list); //反转 Collections.reverse(list); //随机置换 即 元素位置随机,每次执行位置不同 Collections.shuffle(list); System.out.println(list);
List
-
有序
-
可重复
🐮ArrayList
-
底层数据结构是数组 查询快增删慢
-
常见用法:
//多态创建集合对象 List<String> list = new ArrayList<>(); //创建集合对象 //ArrayList<String> array = new ArrayList<>(); //添加元素 list.add("hello"); list.add("world"); list.add("java"); list.add("world"); //索引不要越界 //在此集合中的指定位置插入指定元素 list.add(3,"javaee"); //list.add(13,"javaee"); 索引越界 //删除指定索引处的元素,返回被删除的元素 System.out.println(list.remove(1));//输出被删除元素 //修改指定索引处元素 返回被修改元素 System.out.println(list.set(1,"JAVA"));//输出被删除的元素 //返回指定索引处的元素 System.out.println(list.get(1)); //迭代器遍历 Iterator<String> it = list.iterator(); while (it.hasNext()){ String s = it.next(); System.out.println(s); } System.out.println("-------"); //for遍历 for(int i = 0; i < list.size(); i++){ String s = list.get(i); System.out.println(s); } System.out.println("--------"); //增强for for(String s : list){ System.out.println(s); }
🐴LinkedList
-
底层数据结构是链表 查询慢增删快
-
常见用法:
LinkedList<String> linkedList = new LinkedList<>(); linkedList.add("Hello"); linkedList.add("World"); linkedList.add("Java"); linkedList.addFirst("javase");//在该列表开头插入指定元素 linkedList.addLast("javaee");//在该列表结尾插入指定元素 System.out.println(linkedList.getFirst());//返回列表中第一个元素 System.out.println(linkedList.getLast());//返回列表中最后一个元素 System.out.println(linkedList.removeFirst());//从列表中删除并返回第一个元素 System.out.println(linkedList.removeLast());//从列表中删除并返回最后一个元素 //迭代器 Iterator<String> itLink = linkedList.iterator(); while (itLink.hasNext()){ String s = itLink.next(); System.out.println(s); }
Set
- 不包含重复元素
- 没有带索引的方法 不能使用普通for遍历
🐶HashSet
-
对集合的迭代顺序不做保证
-
底层数据结构是哈希表
-
没有带索引方法 不能使用普通for遍历
-
由于是Set集合 不包含重复元素
-
常见用法:
//多态创建集合对象 Set<String> set = new HashSet<>(); //添加元素 set.add("Hello"); set.add("World"); set.add("Java"); set.add("World");//不包含重复元素 //遍历 //增强for for(String s : set){ System.out.println(s); } System.out.println("------"); //迭代器 Iterator<String> it = set.iterator(); while (it.hasNext()){ String s = it.next(); System.out.println(s); }
哈希值
-
JDK根据对象的 地址或字符串或数字 计算 出的 int 类型的数值
-
同一个对象多次调用hashCode相同
-
默认情况下,不同对象调用hashCode不同
-
通过方法重写 可以实现不同对象相同哈希值
-
对于中文字符串重写了哈希值
//有外部学生类 Student s1 = new Student("小黑", 25); //获取哈希值 //同一个对象多次调用hashCode相同 System.out.println(s1.hashCode());//1163157884 System.out.println(s1.hashCode());//1163157884 System.out.println("--------"); Student s2 = new Student("小黑", 25); //默认情况下,不同对象调用hashCode不同 //通过方法重写 可以实现不同对象相同哈希值 System.out.println(s2.hashCode());//1956725890 System.out.println("Hello".hashCode());//69609650 System.out.println("World".hashCode());//83766130 System.out.println("Java".hashCode());//2301506 //对于中文字符串重写了哈希值 为相同哈希值 System.out.println("重地".hashCode());//1179395 System.out.println("通话".hashCode());//1179395
🐺LinkedHashSet
-
由哈希表和链表实现的Set接口,具有可预测的迭代顺序
-
由链表保证元素有序,也就是说元素的存储和取出顺序是一致的
-
由哈希表保证元素唯一 即 没有重复元素
LinkedHashSet<String> lhs = new LinkedHashSet<>(); lhs.add("Hello"); lhs.add("World"); lhs.add("Java"); lhs.add("World");//没有重复元素 for(String s : lhs){ System.out.println(s); }
🐷TreeSet
-
元素有序
-
- TreeSet():根据自然排序
- TreeSet(Comparator comparator):根据指定比较器进行排序
- TreeSet():根据自然排序
-
没有带索引的方法 不能使用普通for
-
由于是Set集合 不包含重复元素集合
TreeSet<Integer> ts = new TreeSet<>(); ts.add(10); ts.add(40); ts.add(50); ts.add(20); //ts.add(50);不包含重复元素 for(Integer i : ts){ System.out.println(i);//自然排序 }
Comparable自然排序
-
重写方法 注意排序规则必须按照要求的主要条件和次要条件来写
-
类需要先 implements Comparable<>即实现类
public class Student implements Comparable<Student> {//实现类 //学生类 @Override//重写 public int compareTo(Student s) { //return 0; 不添加 //return 1; 升序 //return -1; 降序 //按照年龄从大到小排序 //int num = this.age - s.age;//年龄升序 age > 1 int num = s.age - this.age;//年龄降序 age < 1 //次要条件排序 当年龄相同时按姓名字母排序 int num2 = num == 0 ? this.name.compareTo(s.name) : num; return num2; } }
//存储学生对象并遍历 创建TreeSet集合使用 无参构造方法 自然排序 //创建集合对象 TreeSet<Student> ts = new TreeSet<>(); //创建学生对象 Student s1 = new Student(); s1.setName("xishi"); s1.setAge(22); Student s2 = new Student("wangzhaojun", 23); Student s3 = new Student("diaochan", 24); Student s4 = new Student("yangyuhuan", 25); Student s5 = new Student("sudaji", 24); //学生添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //增强for for (Student s : ts) { System.out.println(s.getName() + "," + s.getAge()); } 输出: yangyuhuan,25 diaochan,24 sudaji,24 wangzhaojun,23 xishi,22
Comparator比较器排序
-
注意排序规则必须按照要求的主要条件和次要条件来写
//存储学生对象并遍历 创建TreeSet集合使用 带参构造方法 比较器排序 //有外部学生类 //创建集合对象 TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {//比较器 @Override//重写 public int compare(Student s1, Student s2) { //this.age-----s1 //s.age-----s2 int num = s1.getAge() - s2.getAge(); int num2 = num == 0 ? s1.getName().compareTo(s2.getName()) : num; return num2; } }); //创建学生对象 Student s1 = new Student(); s1.setName("xishi"); s1.setAge(22); Student s2 = new Student("wangzhaojun", 23); Student s3 = new Student("diaochan", 24); Student s4 = new Student("yangyuhuan", 25); Student s5 = new Student("sudaji", 24); //学生添加到集合 ts.add(s1); ts.add(s2); ts.add(s3); ts.add(s4); ts.add(s5); //增强for for (Student s : ts) { System.out.println(s.getName() + "," + s.getAge()); } 输出: xishi,22 wangzhaojun,23 diaochan,24 sudaji,24 yangyuhuan,25
Map集合
- 存储键/值对
- 键key唯一,一个键最多能绑定一个值
- 指定的值与该映射中的指定键相关联
- null可以作为键,这样的键只有一个
- 键和值都可以为类或为基本数据类型
🐱HashMap
-
键无序排列
-
覆盖了equals()方法和hashcode()方法,使得HashMap中两个相等的映射返回相同的哈希值
-
Map操作功能:
//创建集合对象 Map<String, String> map = new HashMap<>(); //添加元素 map.put("佩奇", "乔治"); map.put("加菲猫", "欧迪"); map.put("喜羊羊", "灰太狼"); //根据键删除键值对元素 System.out.println(map.remove("佩奇"));//删除键值对 返回 值 System.out.println(map.remove("其他"));//返回null //移除所有键值对元素 //map.clear(); //判断集合是否包含指定的键 System.out.println(map.containsKey("加菲猫"));//返回true或false System.out.println(map.containsKey("其他")); //判断集合是否包含指定的值 System.out.println(map.containsValue("灰太狼"));//返回true或false System.out.println(map.containsValue("其他")); //判断集合是否为空 System.out.println(map.isEmpty());//返回true或false false即不为空 //返回集合长度 System.out.println(map.size()); System.out.println(map);
-
Map集合获取功能:
Map<String, String> map = new HashMap<>(); map.put("佩奇", "乔治"); map.put("加菲猫", "欧迪"); map.put("喜羊羊", "灰太狼"); //根据键获取值 System.out.println(map.get("佩奇"));//乔治 System.out.println(map.get("其他"));//null //获取所有键的集合 Set<String> keySet = map.keySet(); for(String key : keySet){ System.out.println(key); } //获取所有值的集合 Collection<String> values = map.values(); for(String value : values){ System.out.println(value); }
-
Map集合遍历方法1:
Map<String, String> maphm = new HashMap<>(); map.put("佩奇", "乔治"); map.put("加菲猫", "欧迪"); map.put("喜羊羊", "灰太狼"); //获取所有键的集合 Set<String> keySet = maphm.keySet(); //遍历键的集合 获取到每一个键 for (String key : keySet) { String value = maphm.get(key);//根据键去找值 System.out.println(key + "," + value); }
-
Map集合遍历方法2:
Map<String, String> hm = new HashMap<>(); map.put("佩奇", "乔治"); map.put("加菲猫", "欧迪"); map.put("喜羊羊", "灰太狼"); //获取所有键值对对象的集合 Set<Map.Entry<String, String>> entrySet = hm.entrySet(); //遍历键值对对象的集合 得到每一个键值对对象 for (Map.Entry<String, String> me : entrySet) { String key = me.getKey(); String value = me.getValue(); System.out.println(key + "," + value); }
🦊TreeMap
-
键有序排列
-
实现了SortedMap接口,使其有序
注
Student类
-
-
- 代码案例中的外部Student类
-
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;
}
}