集合框架
集合框架
集合类的特点：提供了一种存储空间可变的存储模型，存储的数量容器可以随便发生改变。
collection单列集合
集合层次结构中的根界面。集合表示一组被称为其元素的对象。一些集合元素允许重复元素，而其他集合不允许。有些被命令和其他无序，jdk不提供此接口的任何直接实现，它提供了更具体的子接口实现，如set和list。该界面通常用于传递集合，并在需要最大的通用性的情况下对其进行操作。
collection集合
- 是单例集合的顶层接口，它表示一组对象，这些对象也成为Collection的元素
- jdk不提供此接口的任何直接实现，它提供了更具体的子接口实现
创建collection集合的对象
-
多态的方式
-
具体的实现类ArrayList
-
package xiao; import java.util.ArrayList; import java.util.Collection; /** * 创建collection集合的对象 * 多态的方式 * Arraylist（） */ public class CollectionDemo01 { public static void main(String[] args) { //创建collection集合的对象 Collection<String> c = new ArrayList<String>(); //添加元素，boolean add = （E e） c.add("hello"); c.add("world"); System.out.println(c); } }
collection常用方法
package xiao;
import java.util.ArrayList;
import java.util.Collection;
//alt+7 打开一个窗口，能够看到类的所有信息
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"));
c.add("hello");
c.add("world");
c.add("world");
//boolean remove(Object o)从集合中移除指定的元素
// System.out.println(c.remove("world"));
// System.out.println(c.remove("javee"));
//void clear()：清空集合中的元素
//c.clear();
//boolean contains(Object o);判断集合中是否存在指定的元素
// System.out.println(c.contains("world"));
//boolean isEmpty()：判断集合是否为空
// System.out.println(c.isEmpty());
//int size():集合的长度，也就是集合中元素的个数
System.out.println(c.size());
//输出集合对象
System.out.println(c);
}
}
collection集合的遍历
iterator：迭代器，集合的专用遍历
-
iterator
iterator():返回此集合中元素的迭代器，通过集合的iterator（）方法得到 -
迭代器是通过集合的iterator（）方法得到的，所以我们说它是依赖于集合而存在的。
-
Iterator
iterator():返回此集合中元素的迭代器，通过集合的iterator（）方法得到 -
boolean hasNext();如果迭代具有更多元素，则返回true
package xiao;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("hello");
c.add("world");
c.add("java");
//Iterator<E> iterator():返回此集合中元素的迭代器，通过集合的iterator（）方法得到
Iterator<String> it = c.iterator();
//E next（）：返回迭代中的下一个元素
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
//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);
}
}
}
案例：创建一个存储学生对象的集合，存储3个学生对象，使用程序实现在控制台遍历集合
思路：
-
定义学生类
-
创建Collection集合对象
-
创建学生对象
-
把学生添加到集合
-
遍历集合（迭代器方式）
package com.xiao; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; public class Demo111 { public static void main(String[] args) { //创建Collection集合对象 Collection<Student> c = new ArrayList<Student>(); //创建学生对象 Student s1 = new Student("小明",12); Student s2 = new Student("小红",13); Student s3 = new Student("小白",33); //把学生添加到集合 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()); } } }
package com.xiao;
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;
}
}
List集合
list集合概序：
- 有序集合（也称为序列），用户可以精确控制列表中每个元素的插入位置，用户可以通过整数索引访问元素，并搜索列表中的元素。
- 与set集合不同，列表通常允许重复的元素
list集合特点
- 有序，存储和取出的元素顺序一致
- 可重复，存储的元素可以重复
package com.xiao;
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<>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("world");
//输出集合对象
// System.out.println(list);
//采用迭代器的方式遍历
Iterator<String> it = list.iterator();
while (it.hasNext()){
String s = it.next();
System.out.println(s);
}
}
}
案例：list集合存储学生对象并遍历
package com.xiao;
import java.nio.file.Watchable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo01 {
public static void main(String[] args) {
//创建集合对象
List<Student> list = new ArrayList<Student>();
Student s1 = new Student("小明",12);
Student s2 = new Student("小明1",14);
Student s3 = new Student("小明2",1);
list.add(s1);
list.add(s2);
list.add(s3);
//while循环
Iterator<Student> it = list.iterator();
while (it.hasNext()){
Student s = it.next();
System.out.println(s.getName() + s.getAge());
}
//for循环
for (int i = 0; i < list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName() + s.getAge());
}
}
}
并发修改异常
开发修改异常
ConcurrenModiflcationException
产生的原因：迭代器遍历过程中，通过集合对象修改了集合中元素的长度，造成了迭代器获取元素中判断期修改值和实际修改值不一致。
package com.xiao;
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<String> list = new ArrayList<>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
//遍历集合
// Iterator<String> it = list.iterator();
// while (it.hasNext()){
// String s = it.next();
// if (s.equals("world")){
// list.add("javaeeR");
for (int i = 0; i < list.size(); i++) {
String s = list.get(i);
if (s.equals("world")){
list.add("javaee");
}
}
System.out.println(list);
}
}
Listlterator
listlterator:列表迭代器
- 通过list集合的listIterator（）方法得到，所以说它是list集合特有的迭代器
- 用于允许程序员沿任一方向遍历列表的列表迭代器，在迭代期间修改列表，并获取列表中迭代器的当前位置
listlterator中的方法：
-
E next();返回迭代中的下一个元素
-
boolean hasNext():如果迭代具有更多元素，则返回true
-
E previous（）：返回列表中的还是那个一个元素
-
boolean hasPrevious():如果此列表迭代器在相反方向遍历列表时具有更多元素，则返回true
-
void add(E e):将指定的元素插入列表
-
package com.xiao; import java.util.ArrayList; import java.util.List; import java.util.ListIterator; public class ListIteratorDemo { public static void main(String[] args) { //创建集合对象 List<String> list = new ArrayList<>(); //添加元素 list.add("hello"); list.add("world"); list.add("java"); //通过list集合的listIterator（）方法得到，所以说它是list集合特有的迭代器 // ListIterator<String> lis = list.listIterator(); // while (lis.hasNext()){ // String s = lis.next(); // System.out.println(s); // } // System.out.println("---------------"); // //逆向遍历 // while (lis.hasPrevious()){ // String s = lis.previous(); // System.out.println(s); // } //获取列表迭代器 ListIterator<String> lit = list.listIterator(); while (lit.hasNext()){ String s = lit.next(); if (s.equals("world")){ lit.add("javaee"); } } System.out.println(list); } }增强for循环‘
增强for：简化数组和Collection集合的遍历
- 实现iterable接口的类允许其对象成为增强for语句的目标
- 他是jdk5之后出现的，其内部原理是一个iterator迭代器
增强for的格式
- 格式：
for（元素数据类型变量名：数组或者collection集合）「
//此处使用变量即可，该变量就是元素
」
package com.xiao;
import java.util.ArrayList;
import java.util.List;
public class ForDemo {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5};
for (int i : arr){
System.out.println(i);
}
String[] strArray = {"hello", "awdk", "dawdk"};
for (String s: strArray){
System.out.println(s);
}
ArrayList<String> ar1= new ArrayList<>();
ar1.add("wadaw");
ar1.add("wdfsdadaw");
ar1.add("wadfacaw");
for (String q:ar1
) {
System.out.println(q);
}
}
}
案例：List集合存储学生对象用三种方式遍历
package com.xiao;
import java.util.ArrayList;
import java.util.ListIterator;
public class ListDemo3 {
public static void main(String[] args) {
ArrayList<Student> str = new ArrayList<Student>();
Student s1 = new Student("小明", 12);
Student s2 = new Student("小1", 14);
Student s3 = new Student("小2", 13);
str.add(s1);
str.add(s2);
str.add(s3);
ListIterator<Student> l1 = str.listIterator();
while (l1.hasNext()){
Student s = l1.next();
System.out.println(s.getName()+s.getAge());
}
for (int i = 0;i<str.size();i++){
Student s = str.get(i);
System.out.println(s.getName()+s.getAge());
}
for (Student s: str){
System.out.println(s.getName()+s.getAge());
}
}
}
list数据结构
栈和队列
数据结构是计算机存储，组织数据的方式。使之相互之间存在一种或多种特定关系的数据元素的集合
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。
-
栈是一种数据先进后出的模型
-
队列是一种数据先进先出的模型
数组
数组是一种查询快，增删慢的模型
-
查询数据通过索引定位，查询任意数据耗时相同，查询效率高。
-
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
-
添加数据时，添加为之后的每个数据后移，在添加元素，添加效率极低
链表
- 链表是一种增删快的模型（对比数组）
- 链表是一种查询慢的模型（对比数组）
list集合子类特点
list集合常用子类：ArrayList（数组）、LinkedList（链表）
练习：分别使用ArrayList和LinkedList完成存储字符串并遍历
package com.xiao;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class ListDemo1 {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> array = new ArrayList<>();
array.add("dawdw");
array.add("dawdgdrgdw");
array.add("dawdawd");
//遍历
for (int i = 0; i < array.size(); i++) {
String s = array.get(i);
System.out.println(s);
}
for (String s: array
) {
System.out.println(s);
}
ListIterator<String> arry = array.listIterator();
while (arry.hasNext()){
String s = arry.next();
System.out.println(s);
}
LinkedList<String> array1 = new LinkedList<>();
for (String s: array
) {
System.out.println(s);
}
for (int i = 0; i < array.size(); i++) {
String s = array.get(i);
System.out.println(s);
}
ListIterator<String> arra1 = array1.listIterator();
while (arra1.hasNext()){
String s = arra1.next();
System.out.println(s);
}
}
}
LinkedList集合的特有功能
package com.xiao;
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList<String> list = new LinkedList<>();
list.add("dadaw");
list.add("dadaw");
list.add("dadaw");
//在该刘表开头拆入制定元素
//将指定的元素追加到此列表的末尾
// list.addFirst("javaee");
// list.addLast("11111");
// System.out.println(list);
//返回此列表中的第一个元素
//返回此列表的最后一个元素
System.out.println(list.getFirst());
System.out.println(list.getLast());
System.out.println(list);
//从此列表中删除并返回第一个元素
//从此列表中删除并返回最后一个元素
System.out.println(list.removeFirst());
System.out.println(list.removeLast());
System.out.println(list);
}
}
set集合
set集合特点：
- 不包含重复元素的集合
- 没有带索引的方法，所以不能使用普通for循环遍历
set集合联系
- 存储字符串并遍历
package com.xiao;
import java.util.HashSet;
public class Setdemo {
public static void main(String[] args) {
HashSet<String> set = new HashSet<>();
set.add("dwad");
set.add("dwaawdawdd");
set.add("dwaawdawddwadadaw");
for (String s :set
) {
System.out.println(s);
}
}
}
哈希值
哈希值：是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
- public int hasCode();返回对象的哈希值
特点：
-
同一个对象多次调用hashcode（）方法返回的哈希值是相同的
-
默认情况下不同对象的哈希值是不相同的，通过方法重写，可以实现不同对象的哈希值是相同的
-
package com.xiao; public class HasDemo { public static void main(String[] args) { Student s1 = new Student("小明2",11); //同一个对象多次调用hascode方法返回的值是一样的 System.out.println(s1.hashCode()); System.out.println(s1.hashCode()); //默认情况下不同对象的哈希值是不相同的 //通过方法重写，可以实现不同对象的哈希值是相同的 Student s2 = new Student("小明2",11); System.out.println(s2.hashCode()); System.out.println("hello".hashCode()); System.out.println("world".hashCode()); System.out.println("java".hashCode()); System.out.println("重地".hashCode()); System.out.println("通话".hashCode()); } }
HashSet集合概述和特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不做任何保证，也就是说不保证存储和取出的元素顺序一样
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是set集合，所以是不包含重复元素的集合
hashset集合练习，存储字符串并遍历：
package com.xiao;
import java.util.HashSet;
public class HashCode {
public static void main(String[] args) {
//创建集合对象
HashSet<String> hs = new HashSet<>();
hs.add("sdasd");
hs.add("sdasdasdasd");
hs.add("sdasdasdasdawdwad");
hs.add("sdasd");
for (String s : hs
) {
System.out.println(s);
}
}
}
哈希表
- jdk8之前，底层采用“数组”+“链表”实现。可以说是一个元素为链表的数组
- jdk8之后，在长度比较长的时候，底层实现了优化
LinkedHashSet集合特点
- 哈希表和链表实现的借口，具有可预测的迭代为序
- 由链表保证元素有序，也就是说元素的存储和取出的顺序是一致的
- 由哈希表办证元素唯一，也就是说没有重复的元素
likedhashset集合练习
-
存储字符串并遍历
-
package com.xiao; import java.util.HashSet; import java.util.LinkedHashSet; public class HashCode { public static void main(String[] args) { //创建集合对象 LinkedHashSet<String> link = new LinkedHashSet<>(); link.add("dawd"); link.add("dawdawdaw"); link.add("dawdawdawawdaw"); link.add("dawdawdawawdaw"); for (String s:link ) { System.out.println(s); } } }
TreeSet集合概述和特点
- 元素有序，这里的顺序不是指的存储和取出顺序，而是按照一定的规矩进行排序，具体排序方法取决于构造方法
- TreeSet();根据其元素的自然排序进行排序
- TreeSer(Comparator comparator):根据指定的比较器进行排序
- 没有带索引的方法，所以不能使用普通for循环遍历
- 由于是set集合，所以不包含重复元素的集合
TreeSet集合练习：
- 存储整数并遍历
package com.xiao;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
public class HashCode {
public static void main(String[] args) {
//创建集合对象
TreeSet<Integer> treeSet = new TreeSet<>();
treeSet.add(12);
treeSet.add(22);
treeSet.add(14);
treeSet.add(14);
treeSet.add(30);
for (Integer i:treeSet
) {
System.out.println(i);
}
}
}
自然排序Comparable的使用
- 存储学生对象并遍历，创建TreeSet集合使用无参构造
- 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
结论：
-
用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
-
自然排序，就是让元素所属的类实现Comparable接口，重写comparaTo(To)方法
-
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
-
package com.xiao; import apple.laf.JRSUIUtils; import java.util.HashSet; import java.util.LinkedHashSet; import java.util.TreeSet; public class HashCode { public static void main(String[] args) { //创建集合对象 TreeSet<Student> ts = new TreeSet<>(); Student student1 = new Student("西施",30); Student student2 = new Student("王昭君",20); Student student3 = new Student("貂蝉",10); Student student4 = new Student("杨玉环",19); Student student5 = new Student("林青霞",19); ts.add(student1); ts.add(student2); ts.add(student3); ts.add(student4); ts.add(student5); for (Student s:ts ) { System.out.println(s.getName()+s.getAge()); } } }
package com.xiao;
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 o) {
// return -1;
// return 1;
// return 0;
//按照年龄从小到达排序
int num = this.age - o.age;
// int num= o.age - this.age;
int num2 = num == 0? this.name.compareTo(o.name):num;
return num2;
}
}
Map集合该序和使用
-
interface Map<K,V> K：键的类型 V:值的类型
-
将键映射到值的对象；不能包含重复的键；每个键可以映射到最多一个值
-
package com.xiao; import java.util.Comparator; import java.util.HashMap; import java.util.Map; import java.util.TreeSet; public class Demo01 { public static void main(String[] args) { //创建集合对象 Map<String,String> map = new HashMap<String,String>(); map.put("itheriwad001","小明"); map.put("itheriwad002","小标"); map.put("itheriwad003","小如"); map.put("itheriwad003","小哦");//第二次出现就修改之前的数据 System.out.println(map); } }
Map集合基本功能
package com.xiao;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.TreeSet;
public class Demo01 {
public static void main(String[] args) {
//创建集合对象
HashMap<String, String> map = new HashMap<>();
//添加
map.put("附加","1");
map.put("郭靖","黄蓉");
map.put("杨过","小龙女");
//根据键删除键值对元素
// System.out.println(map.remove("郭靖"));
// System.out.println(map.remove("国祥"));
//移除所有的键值对元素
//map.clear();
// //判断集合是否还包含指定的键
// System.out.println(map.containsKey("杨过"));
// System.out.println(map.containsKey("过"));
//判断集合是否包含指定的值
// System.out.println(map.containsValue("1"));
//判断集合是否为空
// System.out.println(map.isEmpty());
//集合的长度，也就是集合中键值对的个数
System.out.println(map.size());
System.out.println(map);
}
}
map集合的获取功能
package com.xiao;
import java.util.*;
public class Demo01 {
public static void main(String[] args) {
//创建集合对象
HashMap<String, String> map = new HashMap<>();
map.put("1","4");
map.put("2","5");
map.put("3","6");
//根据键获取值
// System.out.println(map.get("2"));
// System.out.println(map.get("7"));
//获取所有键的集合
// Set<String> keyset = map.keySet();
// for (String s:keyset
// ) {
// System.out.println(s);
// }
//获取所有值的集合
// Collection<String> values = map.values();
// for (String v:values
// ) {
// System.out.println(v);
// }
}
}
Map集合的遍历（方式一）
遍历思路：
- 获取所有键的集合，用keyset方法实现
- 遍历键的集合，获取到每一个键，用增强for实现
- 根据键去找值，用get（obejctkey）方法实现
package com.xiao;
import java.util.*;
public class Demo01 {
public static void main(String[] args) {
//创建集合对象
HashMap<String, String> map = new HashMap<>();
map.put("1","2");
map.put("3","4");
map.put("5","6");
//获取所有键的集合，用keyset方法实现
Set<String> keySet = map.keySet();
for (String key:keySet
) {
String value = map.get(key);
System.out.println(key+value);
}
}
}
Map集合遍历（方式二）
遍历思路：
-
获取map集合中队友键值对对象的集合
- Set<Map.Entry<K,y> > entrySer():获取所有键值对对象的集合
-
遍历键值对对象的集合，得到每一个键值对对象
- 用增强for实现，得到每一个Map.Entry
-
根据键值对对象获取键和值
- 用getkey（）得到键
- 用getvalur（） 得到值
package com.xiao;
import java.util.*;
public class Demo01 {
public static void main(String[] args) {
//创建集合对象
HashMap<String, String> map = new HashMap<>();
map.put("1","2");
map.put("3","4");
map.put("5","6");
//获取map集合中队友键值对对象的集合
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);
}
}
}
ArrayList嵌套HashMap
案例：
package com.xiao;
import java.nio.charset.StandardCharsets;
import java.util.*;
public class Demo01 {
public static void main(String[] args) {
//创建ArrayList集合
ArrayList<HashMap<String, String>> array = new ArrayList<>();
//创建hashmap集合并添加
HashMap<String, String> hm1 = new HashMap<>();
hm1.put("1","2");
hm1.put("3","4");
array.add(hm1);
HashMap<String, String> hm2 = new HashMap<>();
hm1.put("5","6");
hm1.put("7","8");
array.add(hm2);
HashMap<String, String> hm3 = new HashMap<>();
hm1.put("a","b");
hm1.put("c","d");
array.add(hm3);
for (HashMap<String, String> hm:array) {
Set<String> keySet = hm.keySet();
for (String ket:keySet
) {
String value = hm1.get(ket);
System.out.println(ket+"," + value);
}
}
}
}
浙公网安备 33010602011771号