第一部分 Collection集合
1.1 请简述集合框架
- 解答：
- 集合按照其存储结构可以分为两大类，分别是单列集合java.util.Collection和双列集合java.util.Map。
- Collection：单列集合类的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是java.util.List和java.util.Set。其中，List的特点是元素有序、元素可重复。Set的特点是元素无序，而且不可重复。List接口的主要实现类有java.util.ArrayList和java.util.LinkedList，Set接口的主要实现类有java.util.HashSet和java.util.TreeSet。
1.2 Collection集合：统计元素出现次数
- 给定以下代码，请定义方法listTest()统计集合中指定元素出现的次数，如"a": 2,“b”: 2,“c” :1, “xxx”:0。
Collection<String> list = new ArrayList<>(); list.add("a"); list.add("a"); list.add("b"); list.add("b"); list.add("c"); System.out.println("a:"+listTest(list, "a")); System.out.println("b:"+listTest(list, "b")); System.out.println("c:"+listTest(list, "c")); System.out.println("xxx:"+listTest(list, "xxx")); - 解答：
主方法：CollectionTest01.java public class CollectionTest01 { //定义方法统计集合中指定元素出现的次数 public static int listTest(Collection<String> list, String str){ int count = 0; for (String s : list) { if(s.equals(str)){ count++; } } return count; } public static void main(String[] args) { Collection<String> list = new ArrayList<>(); list.add("a"); list.add("a"); list.add("b"); list.add("b"); list.add("c"); System.out.println("a:"+listTest(list, "a")); System.out.println("b:"+listTest(list, "b")); System.out.println("c:"+listTest(list, "c")); System.out.println("xxx:"+listTest(list, "xxx")); } } //结果： a:2 b:2 c:1 xxx:0
1.3 Collection集合：数组转集合
- 定义一个方法，要求此方法把int数组转成存有相同元素的集合(集合里面的元素是Integer)，并返回。
- 解答：
//主方法：CollectionTest02.java public class CollectionTest02 { public static List<Integer> transform(int[] arr){ List<Integer> listA = new ArrayList<>(); for (int i : arr) { listA.add(i); } return listA; } public static void main(String[] args) { int[] array = {1, 3, 5, 6, 9}; List<Integer> listA1 = transform(array); System.out.println(listA1); /*Iterator<Integer> it = listA1.iterator(); while(it.hasNext()){ Integer next = it.next(); System.out.print(next + " "); }*/ } } //结果： [1, 3, 5, 6, 9]
1.4 Collection集合：集合转数组
- 定义一个集合，并把集合(集合里面的元素是Integer)转成存有相同元素的数组，并将结果输出在控制台。（可以使用Object[]数组类型接收转换的数组）
- 解答：
//主方法：CollectionTest03.java public class CollectionTest03 { public static void main(String[] args) { List<Integer> listA = new ArrayList<>(); listA.add(233); listA.add(377); listA.add(610); listA.add(987); //自己 /*Object[] obj = new Object[listA.size()]; for(int i = 0; i < listA.size(); i++){ obj[i] = listA.get(i); } System.out.println(Arrays.toString(obj)); //[233, 377, 610, 987]*/ //官方 Object[] obj = listA.toArray(); //转换为数组 for(int i = 0; i < obj.length; i++){ System.out.print(obj[i] + " "); //233 377 610 987 } } } //结果： 233 377 610 987
1.5 Collection集合：contains()方法使用
- 定义一个方法listTest(ArrayList al, String s),要求使用contains()方法判断al集合里面是否包含字符串s
- 解答：
//主方法：CollectionTest04.java public class CollectionTest04 { public static void main(String[] args) { ArrayList<String> aL = new ArrayList<>(); aL.add("itcast"); aL.add("itheima"); aL.add("java"); System.out.println(listTest(aL, "java")); } public static boolean listTest(ArrayList<String> al, String s){ //判断s是否在集合中存在,存在返回true，不存在返回false //官方 if(al.contains(s)){ return true; } return false; //自己 /*boolean contains = false; for (String s1 : al) { if(s1.contains(s)){ contains = true; } } return contains;*/ } } //结果： true
1.6 Collection集合：isEmpty()方法的使用
- 定义一个方法listTest(ArrayList al), 要求使用isEmpty()判断al里面是否有元素
- 解答：
//主方法：CollectionTest05.java public class CollectionTest05 { public static void main(String[] args) { ArrayList<String> listA = new ArrayList<>(); listA.add("java"); listA.add("one"); System.out.println(listTest(listA)); } public static boolean listTest(ArrayList<String> al){ if(al.isEmpty()){ return true; } return false; } } //结果： false
1.7 Collection集合：简述迭代器的实现原理
- 解答：
- 当遍历集合时，首先通过调用集合的iterator()方法获得迭代器对象，然后使用hashNext()方法判断集合中是否存在下一个元素，如果存在，则调用next()方法将元素取出，否则说明已到达了集合末尾，停止遍历元素。
- Iterator迭代器对象在遍历集合时，内部采用指针的方式来跟踪集合中的元素，在调用Iterator的next()方法之前，迭代器的索引位于第一个元素之前，不指向任何元素，当第一次调用迭代器的next方法后，迭代器的索引会向后移动一位，指向第一个元素并将该元素返回，当再次调用next方法时，迭代器的索引会指向第二个元素并将该元素返回，依此类推，直到hasNext方法返回false，表示到达了集合的末尾，终止对元素的遍历。
1.8 Collection集合：返回首次出现索引*
- 定义一个方法listTest(ArrayList al, Integer s)，要求返回s在al里面第一次出现的索引，如果s没出现过返回-1
- 解答：
//主方法：CollectionTest06.java public class CollectionTest06 { public static void main(String[] args) { ArrayList<Integer> aL = new ArrayList<>(); aL.add(1); aL.add(2); aL.add(3); aL.add(4); aL.add(5); System.out.println(listTest(aL, 2)); } public static int listTest(ArrayList<Integer> al, Integer s){ //遍历集合，获取元素，判断元素是否与s相等，相等返回索引 for(int i = 0; i < al.size(); i++){ if(al.get(i).equals(s)){ return i; } } return -1; } } //结果： 1
第二部分 File类&递归&FileFilter
2.1 相对路径和绝对路径的使用
- 描述:创建两个文件对象，分别使用相对路径和绝对路径创建
- 解答：
- 操作步骤：
- 绝对路径创建文件对象：使用File类一个参数的构造方法。
- 相对路径创建文件对象：使用File类两个参数的构造方法。
- 相对路径就是项目的根目录
- 代码：
public class Test01_01 { public static void main(String[] args) { // 创建文件对象：绝对路径 File f1 = new File("E:\\JavaWebApp\\WorkSpace\\oop\\Test01_01a.txt"); // 创建文件对象：相对路径 File f2 = new File("Test01_01b.txt"); } } - 操作步骤：
2.2 检查文件是否存在,文件的创建：exists，createNewFile
- 描述:检查D盘下是否存在文件a.txt,如果不存在则创建该文件。
- 解答：
- 操作步骤:
- 使用绝对路径创建对象关联到D盘的a.txt。
- 通过文件对象方法判断文件是否存在(exists)。
- 不存在则调用创建文件的方法创建文件(createNewFile->会抛异常)。
- 代码：
import java.io.File; import java.io.IOException; public class Test01_02 { public static void main(String[] args) throws IOException { File f = new File("d:\\a.txt"); // 如果文件不存在，则创建文件 if(!f.exists()){ f.createNewFile(); } } } - 操作步骤:
2.3 单级文件夹的创建：mkdir
- 描述:在D盘下创建一个名为bbb的文件夹。
- 解答：
- 操作步骤:
- 创建文件对象指定路径为d:/bbb
- 调用文件对象创建文件夹的方法
- 代码：
import java.io.File; public class Test01_03 { public static void main(String[] args) { // 创建文件对象 File f = new File("d:\\bbb"); // 创建单级文件夹 f.mkdir(); } } - 操作步骤:
2.4 多级文件夹的创建：mkdirs
- 描述:在D盘下创建一个名为ccc的文件夹，要求如下：
- ccc文件夹中要求包含bbb子文件夹
- bbb子文件夹要求包含aaa文件夹
- 解答：
- 操作步骤:
- 创建文件对象关联路径：d:/ccc/bbb/aaa
- 调用文件对象创建多级文件夹的方法
- 代码：
import java.io.File; public class Test01_04 { public static void main(String[] args) { // 创建文件对象 File f = new File("d:\\ccc\\bbb\\aaa"); // 创建多级文件夹 f.mkdirs(); } } - 操作步骤:
2.5 删除文件和文件夹：delete
- 描述:
- 将D盘下a.txt文件删除
- 将D盘下aaa文件夹删除,要求文件夹aaa是一个空文件夹。
- 解答：
- 操作步骤:
- 创建文件对象关联路径：d:/a.txt
- 调用文件对象删除文件的方法
- 创建文件对象关联路径：d:/aaa
- 调用文件对象删除文件夹的方法
- 代码：
import java.io.File; public class Test01_05 { public static void main(String[] args) { File f = new File("D:\\a.txt"); f.delete(); File dir = new File("d:\\aaa"); dir.delete(); } } - 操作步骤:
2.6 获取文件信息:文件名,文件大小,文件的绝对路径,文件的父路径
- 描述:
- 获取D盘aaa文件夹中b.txt文件的文件名，文件大小，文件的绝对路径和父路径等信息，并将信息输出在控制台。
- 解答：
- 操作步骤:
- 在D盘aaa文件夹中创建一个b.txt文件并输入数据
- 创建文件对象关联路径：d:/aaa/b.txt
- 调用文件对象的相关方法获得信息并输出。可以通过API帮助文档查询方法。
- getName// 获得文件名
- length// 获得文件大小
- getAbsolutePath// 获得文件的绝对路径
- getParent// 获得父文件夹路径，返回字符串
- getParentFile// 获得父文件夹路径，返回文件对象
- 代码：
import java.io.File; public class Test01_06 { public static void main(String[] args) { // 创建文件对象 File f = new File("d:\\aaa\\b.txt"); // 获得文件名 String filename = f.getName(); // 获得文件大小 long filesize = f.length(); // 获得文件的绝对路径 String path = f.getAbsolutePath(); // 获得父文件夹路径，返回字符串 String parentPath = f.getParent(); // 获得父文件夹路径，返回文件对象 File parentFile = f.getParentFile(); // 输出信息 System.out.println("文件名：" + filename); System.out.println("文件大小：" + filesize); System.out.println("文件路径：" + path); System.out.println("文件父路径：" + parentPath); System.out.println("文件父路径：" + parentFile); } } //结果： 文件名：b.txt 文件大小：21 文件路径：d:\aaa\b.txt 文件父路径：d:\aaa 文件父路径：d:\aaa - 操作步骤:
2.7 文件夹或文件的判断：isFile(文件)，isDirectory(文件夹)
- 描述:
- 判断File对象是否是文件,是文件则输出：xxx是一个文件，否则输出：xxx不是一个文件。
- 判断File对象是否是文件夹,是文件夹则输出：xxx是一个文件夹，否则输出：xxx不是一个文件夹。(xxx是文件名或文件夹名)
- 解答：
- 操作步骤:
- 创建两个文件对象分别关联到不同的文件，比如：d:/a.txt，d:/aaa
- 调用文件对象的判断是否是文件或是否是文件夹的方法
- 获得文件名，根据判断结果输出信息。
- 代码：
import java.io.File; public class Test01_07 { public static void main(String[] args) { // 创建文件对象 File f1 = new File("d:\\b.txt"); // 判断是否是一个文件 if(f1.isFile()) { System.out.println(f1.getName()+"是一个文件"); } else { System.out.println(f1.getName()+"不是一个文件"); } // 创建文件对象 File f2 = new File("d:\\aaaa"); // 判断是否是一个文件夹 if(f2.isDirectory()) { System.out.println(f2.getName()+"是一个文件夹"); } else { System.out.println(f2.getName()+"不是一个文件夹"); } } } //结果： b.txt是一个文件 aaaa是一个文件夹 - 操作步骤:
2.8 文件夹的获取方法
- 描述:
- 获取指定文件夹下所有的文件和文件夹，并将所有文件和文件夹的名字输出到控制台。
- 注意：不包含子文件夹下的文件
- 解答：
- 操作步骤:
- 创建文件对象关联到指定文件夹，比如：c:/aaa
- 调用文件对象的listFiles方法获得文件数组
- 遍历文件数组将每一个文件的名字输出到控制台
- 代码：
import java.io.File; public class Test01_08 { public static void main(String[] args) { // 创建文件对象 File f = new File("d:\\aaa"); // 获得文件夹下所有文件 File[] files = f.listFiles(); // 遍历文件数组 for (File file :files) { // 将文件的名字打印到控制台 System.out.println(file.getName()); } } } //结果： b.txt bbb - 操作步骤:
第三部分 List集合&Set集合
3.1 List接口的特点
- 描述:请简述List接口的特点
- 解答：
- 它是一个元素存取有序的集合。例如，存元素的顺序是11、22、33。那么集合中，元素的存储就是按照11、22、33的顺序完成的）。
- 它是一个带有索引的集合，通过索引就可以精确的操作集合中的元素（与数组的索引是一个道理）。
- 集合中可以有重复的元素，通过元素的equals方法，来比较是否为重复的元素。
3.2 hashCode和equals方法
- 描述：请简述HashSet去除重复元素的原理
- 注：用HashSet存储自定义类型的元素，必须重写hashCode和equals方法
- 解答：
- 调用被添加元素的hashCode()，和HashSet中已有元素的hashCode比较是否相同
- 如果不相同，直接存储
- 如果相同，调用equals方法比较是否相同
- 不相同，直接存储元素
- 相同，认为是同一元素.不存储
3.3 数据结构
- 描述：简述常见的数据结构中元素的存取特点
- 解答：
- 栈：stack，又称堆栈，对元素的存取特点是：先进后出。即，存进去的元素，要在后它后面的元素依次取出后，才能取出该元素。
- 队列：queue，简称队，对元素的存取特点是：先进先出。即，存进去的元素，要在后它前面的元素依次取出后，才能取出该元素。
- 数组:Array，是有序的元素序列，对元素的存取特点是：
- 查找元素快：通过索引，可以快速访问指定位置的元素
- 增删元素慢
- 指定索引位置增加元素：需要创建一个新数组，将指定新元素存储在指定索 引位置，再把原数组元素根据索引，复制到新数组对应索引的位置。
- 指定索引位置删除元素：需要创建一个新数组，把原数组元素根据索引，复 制到新数组对应索引的位置，原数组中指定索引位置元素不复制到新数组中。
- 链表:linked list，对元素的存取有如下的特点：
- 多个结点之间，通过地址进行连接。例如，多个人手拉手，每个人使用自己的 右手拉住下个人的左手，依次类推，这样多个人就连在一起了。
- 查找元素慢：想查找某个元素，需要通过连接的节点，依次向后查找指定元素。
- 增删元素快：
- 增加元素：只需要修改连接下个元素的地址即可。
- 删除元素：只需要修改连接下个元素的地址即可。
3.4 Comparable和Comparator比较器
- 描述：四、简述Comparable和Comparator两个接口的区别
- 解答：
- Comparable：强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。只能在类中实现compareTo()一次，不能经常修改类的代码实现自己想要的排序。实现此接口的对象列表（和数组）可以通过Collections.sort（和Arrays.sort）进行自动排序，对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
- Comparator强行对某个对象进行整体排序。可以将Comparator传递给sort方法（如Collections.sort或Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用Comparator来控制某些数据结构（如有序set或有序映射）的顺序，或者为那些没有自然顺序的对象collection提供排序。
- 笔记解答：
- Comparable:自己（this）和别人（参数）比较，自己需要实现Comparable接口，重写比较的规则compareTo方法
- Comparator：相当于找了一个第三方裁判，比较两个人，重写了compare方法
//例：默认 Collections.sort(listA); //Comparator规则sort——升序 Collections.sort(listA, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o1 - o2; } });
3.5 LinkedList方法的使用
- 描述：根据要求练习LinkedList方法：
- 基本方法：add, set, get, remove, clear, size等方法；
- 特有方法：addFirst, addLast, getFirst, getLast, removeFirst, removeLast, push（在集合开头插入元素，相当于addFirst）, pop（弹出第一个元素）, clear等方法。
- 解答：
- 基本方法：
public class LinkedListTest01 { public static void main(String[] args) { // 1.创建LinkedList LinkedList<String> arr = new LinkedList<String>(); // 2.使用add方法添加元素 arr.add("西门吹雪"); arr.add("西门吹雪"); arr.add("西门吹雪"); arr.add("西门吹风"); arr.add("西门吹水"); // 3.使用add方法在指定索引添加元素 arr.add(2, "西门吹雨"); // 4.使用set方法修改指定位置索引 arr.set(0, "东门"); for (String str : arr) { System.out.println(str); } System.out.println("--------------"); // 5.使用get方法获取指定索引的元素 System.out.println(arr.get(1)); // 6.使用size方法获取集合大小 System.out.println(arr.size()); // 7.使用remove方法删除指定索引的元素 arr.remove(3); // 8.使用clear清空集合中的元素 arr.clear(); System.out.println(arr); } } //结果： 东门 西门吹雪 西门吹雨 西门吹雪 西门吹风 西门吹水 -------------- 西门吹雪 6 []- 特有方法：
public class LinkedListTest02 { public static void main(String[] args) { // 1.创建LinkedList LinkedList<String> linked = new LinkedList<String>(); // 2.使用add方法添加元素 linked.add("周杰伦"); linked.add("周星驰"); linked.add("周华健"); linked.add("周润发"); // 3.使用addFirst添加元素到集合最前面 linked.addFirst("周传雄"); // 4.使用addLast添加元素到集合最后面 linked.addLast("周渝民"); System.out.println(linked); // 5.使用getFirst获取集合第一个元素 System.out.println(linked.getFirst()); // 6.使用getLast获取集合最后一个元素 System.out.println(linked.getLast()); // 7.使用removeLast删除集合第一个元素 String first = linked.removeFirst(); System.out.println(first); // 8.使用removeLast删除集合最后一个元素 String last = linked.removeLast(); System.out.println(last); System.out.println(linked); // 9.使用pop弹出第一个元素 String p = linked.pop(); System.out.println(p); // 10.使用push在集合开头插入元素 linked.push("周立波"); System.out.println(linked); // 11.使用clear清空集合 linked.clear(); System.out.println(linked); } } //结果： [周传雄, 周杰伦, 周星驰, 周华健, 周润发, 周渝民] 周传雄 周渝民 周传雄 周渝民 [周杰伦, 周星驰, 周华健, 周润发] 周杰伦 [周立波, 周星驰, 周华健, 周润发] []
3.6 HashSet存储自定义类型
- 描述：
- 定义人类，包含姓名和年龄属性。创建4个人存储到HashSet中，姓名和年龄相同的人看做同一人不存储。
- 解答：
// 1.定义Person类.包好姓名年龄属性,重写hashCode()和equals()方法 public class Person { private String name; private int age; public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Person)) return false; Person person = (Person) o; return getAge() == person.getAge() && Objects.equals(getName(), person.getName()); } @Override public int hashCode() { return Objects.hash(getName(), getAge()); } @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", 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; } } //主方法：HashSetTest01.java public class HashSetTest01 { public static void main(String[] args) { // 2.创建HashSet用于存储Person类型 HashSet<Person> hashSet = new HashSet<>(); // 3.添加多个Person到HashSet中 hashSet.add(new Person("王昭君", 21)); hashSet.add(new Person("西施", 21)); hashSet.add(new Person("杨玉环", 20)); hashSet.add(new Person("貂蝉", 19)); hashSet.add(new Person("杨玉环", 20)); hashSet.add(new Person("貂蝉", 19)); // 4.遍历获取HashSet中的内容 for (Person p : hashSet) { System.out.println(p); } } } //结果： Person{name='王昭君', age=21} Person{name='貂蝉', age=19} Person{name='杨玉环', age=20} Person{name='西施', age=21}
3.7 List集合元素替换
- 描述：
- 向list集合添加姓名{张三,李四,王五,二丫,钱六,孙七},将二丫替换为王小丫
- 解答：
- 注：“二丫”.equals(thisName)把字符串放到前面，，不然容易报错
public class ListTest01 { public static void main(String[] args) { List<String> listA = new ArrayList<>(); listA.add("张三"); listA.add("李四"); listA.add("王五"); listA.add("二丫"); listA.add("钱六"); listA.add("孙七"); //3.遍历集合，找到"二丫",便将其替换为"王小丫" //利用普通for循环遍历List集合 for(int i = 0; i < listA.size(); i++){ String thisName = listA.get(i); if("二丫".equals(thisName)){ listA.set(i, "王小丫"); } } System.out.println(listA); } } //结果： [张三, 李四, 王五, 王小丫, 钱六, 孙七]
3.8 LinkedHashSet基本使用
- 描述：
- 使用LinkedHashSet存储以下元素：“王昭君”,“王昭君”,“西施”,“杨玉环”,“貂蝉”。使用迭代器和增强for循环遍历LinkedHashSet。
- 解答：
public class LinkedHashSetTest01 { public static void main(String[] args) { LinkedHashSet<String> lhSet = new LinkedHashSet<>(); // 2.使用add方法添加元素到LinkedHashSet lhSet.add("王昭君"); lhSet.add("王昭君"); lhSet.add("王昭君"); lhSet.add("西施"); lhSet.add("杨玉环"); lhSet.add("貂蝉"); // 3.使用迭代器获取LinkedHashSet中的元素 Iterator<String> it = lhSet.iterator(); while(it.hasNext()){ String next = it.next(); System.out.println(next + " "); } // 4.使用增强for获取LinkedHashSet中的元素 System.out.println("---------------------"); for (String s : lhSet) { System.out.println(s); } } } //结果： 王昭君 西施 杨玉环 貂蝉 --------------------- 王昭君 西施 杨玉环 貂蝉
3.9 Collections工具类使用
- 描述：
- ArrayList集合中有如下内容： {33,11,77,55}，使用Collections.sort()对ArrayList集合中的数据进行排序，并打印出排序后的结果。
- 解答：
public class CollectionsTest01 { public static void main(String[] args) { List<Integer> listA = new ArrayList<>(); Collections.addAll(listA, 33, 11, 77, 55); Collections.sort(listA); //默认升序 System.out.println(listA); //[11, 33, 55, 77] Collections.sort(listA, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return o2 - o1; //逆序 } }); System.out.println(listA); //[77, 55, 33, 11] } } //结果： [11, 33, 55, 77] [77, 55, 33, 11]
第四部分 Map集合
4.1 Map接口的特点
- 描述：
- 请简述Map 的特点。
- 解答：
- Map每个元素由键与值两部分组成
- Map键不能重复,每个键对应一个值
- 键和值可以为null
4.2 Entry键值对对象
- 描述：
- 说出Entry键值对对象遍历Map集合的原理
- 解答：
- Map中存放的是两种对象，一种称为key(键)，一种称为value(值)，它们在Map中是一一对应关系，这一对对象又称做Map中的一个Entry(项)。Entry将键值对的对应关系封装成了对象。即键值对对象，这样我们在遍历Map集合时，就可以从每一个键值对（Entry）对象中获取对应的键与对应的值。
//使用entrySet Set<Map.Entry<Person, String>> setE = mapH.entrySet(); for (Map.Entry<Person, String> pE : setE) { System.out.println("key=" + pE.getKey() + "value=" + pE.getValue()); }
4.3 Map接口中的常用方法
- 描述：
- 请使用Map集合的方法完成添加元素，根据键删除，以及根据键获取值操作
- 解答：
public class MapTest01 { public static void main(String[] args) { // 1.创建HashMap HashMap<String, String> hm = new HashMap<String, String>(); // 2.使用put添加元素 hm.put("黄晓明", "Baby"); hm.put("邓超", "孙俪"); hm.put("李晨", "范冰冰"); hm.put("大黑牛", "范冰冰"); // 3.使用put修改元素 String v1 = hm.put("李晨", "白百合"); // 4.使用get获取元素 String string = hm.get("大黑牛"); // 5.使用remove删除元素 String v2 = hm.remove("大黑牛"); System.out.println(v2); // 6.打印集合中的元素 System.out.println(hm); } } //结果： 范冰冰 {邓超=孙俪, 李晨=白百合, 黄晓明=Baby}
4.4 Map接口中的方法
- 描述：
- 往一个Map集合中添加若干元素。获取Map中的所有value，并使用增强for和迭代器遍历输出每个value。
- 解答：
public class MapTest02 { public static void main(String[] args) { // 1.创建HashMap HashMap<String, String> hm = new HashMap<String, String>(); // 2.使用put添加元素 hm.put("黄晓明", "Baby"); hm.put("邓超", "孙俪"); hm.put("李晨", "范冰冰"); hm.put("大黑牛", "范冰冰"); // 3.使用Map的values方法获取到所有的value Collection<String> values = hm.values(); // 4.使用增强for获取每个value for (String value : values) { System.out.println(value); } System.out.println("----------------"); // 5.使用迭代器获取每个value Iterator<String> itr = values.iterator(); while (itr.hasNext()) { System.out.println(itr.next()); } } } //结果： 孙俪 范冰冰 范冰冰 Baby ---------------- 孙俪 范冰冰 范冰冰 Baby
4.5 HashMap存储键是自定义对象值是String
- 描述：
- 请使用Map集合存储自定义数据类型Car做键，对应的价格做值。并使用keySet和entrySet两种方式遍历Map集合。
- 解答：
// 1.定义汽车类.包含名称和价格属性,重写hashCode和equals方法 public class Car { private String name; private String color; public Car() { } public Car(String name, String color) { this.name = name; this.color = color; } @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Car)) return false; Car car = (Car) o; return Objects.equals(getName(), car.getName()) && Objects.equals(getColor(), car.getColor()); } @Override public int hashCode() { return Objects.hash(getName(), getColor()); } @Override public String toString() { return "Car{" + "name='" + name + '\'' + ", color='" + color + '\'' + '}'; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } } //主方法：MapTest03.java public class MapTest03 { public static void main(String[] args) { // 2.创建HashMapkey保存汽车对象,value是汽车价格 HashMap<Car, Integer> hm = new HashMap<>(); // 3.添加汽车到HashMap中 Car c1 = new Car("长安奔奔", "黄色"); Car c3 = new Car("奇瑞QQ", "黑色"); Car c2 = new Car("铃木奥拓", "白色"); hm.put(c1, 10000); hm.put(c2, 20000); hm.put(c3, 30000); //4.使用keySet方式遍历Map Set<Car> keySet = hm.keySet(); for (Car c : keySet) { Integer value = hm.get(c); System.out.println(c.getName() + ","+ c.getColor() + " - "+ value); } System.out.println("-------------"); // 5.使用entrySet方式遍历Map Set<Map.Entry<Car, Integer>> entrySet = hm.entrySet(); for (Map.Entry<Car, Integer> entry : entrySet) { Car key = entry.getKey(); Integer value = entry.getValue(); System.out.println(key.getName() + ","+ key.getColor() + " - "+ value); } } } //结果： 长安奔奔,黄色 - 10000 铃木奥拓,白色 - 20000 奇瑞QQ,黑色 - 30000 ------------- 长安奔奔,黄色 - 10000 铃木奥拓,白色 - 20000 奇瑞QQ,黑色 - 30000
4.6 Map集合的使用（一）
- 描述：
- 现在有一个map集合如下：
Map<Integer,String> map = new HashMap<Integer, String>(); map.put(1, "张三丰"); map.put(2, "周芷若"); map.put(3, "汪峰"); map.put(4, "灭绝师太"); - 要求：
- 遍历集合，并将序号与对应人名打印。
- 向该map集合中插入一个编码为5姓名为李晓红的信息
- 移除该map中的编号为1的信息
- 将map集合中编号为2的姓名信息修改为"周林"
- 解答：
public class MapTest04 { public static void main(String[] args) { Map<Integer,String> map = new HashMap<Integer, String>(); map.put(1, "张三丰"); map.put(2, "周芷若"); map.put(3, "汪峰"); map.put(4, "灭绝师太"); //1.遍历集合，并将序号与对应人名打印。->keySet Set<Integer> keySet = map.keySet(); for (Integer key : keySet) { String value = map.get(key); System.out.println(key + " -- "+ value); } //2. 向该map集合中插入一个编码为5姓名为李晓红的信息 map.put(5, "李晓红"); //3. 移除该map中的编号为1的信息 map.remove(1); //4. 将map集合中编号为2的姓名信息修改为"周林" map.put(2, "周林"); System.out.println("============="); //修改之后 Set<Integer> keySet1 = map.keySet(); for (Integer key : keySet1) { String value = map.get(key); System.out.println(key + " -- "+ value); } } } //结果： 1 -- 张三丰 2 -- 周芷若 3 -- 汪峰 4 -- 灭绝师太 ============= 2 -- 周林 3 -- 汪峰 4 -- 灭绝师太 5 -- 李晓红
4.7 Map集合的使用（二）
- 描述：
- 有2个数组，第一个数组内容为：[黑龙江省,浙江省,江西省,广东省,福建省]，第二个数组为：[哈尔滨,杭州,南昌,广州,福州]，将第一个数组元素作为key，第二个数组元素作为value存储到Map集合中。如{黑龙江省=哈尔滨, 浙江省=杭州, …}
- 解答：
public class MapTest05 { public static void main(String[] args) { //官方 // 1.定义第一个数组arr1 String[] arr1 = {"黑龙江省", "浙江省", "江西省", "广东省", "福建省"}; // 2.定义第二个数组arr2 String[] arr2 = {"哈尔滨", "杭州", "南昌", "广州", "福州"}; // 3.创建HashMap,key存放省,value存放市 HashMap<String, String> hm = new HashMap<>(); // 4.使用普通for循环遍历arr1 for (int i = 0; i < arr1.length; i++) { // 5.根据索引到arr1中获取到省 String key = arr1[i]; // 6.根据索引到arr2中获取到省会城市 String value = arr2[i]; // 7.将省和省会城市添加到HashMap中 hm.put(key, value); } // 8.输出HashMap中的内容 //System.out.println(hm); //keySet方式 Set<String> set = hm.keySet(); for (String key : set) { String value = hm.get(key); System.out.println(key + "=" + value); } //自己 /*HashMap<String[], String[]> hm = new HashMap<>(); String[] shen = {"黑龙江省", "浙江省", "江西省", "广东省", "福建省"}; String[] zhou = {"哈尔滨", "杭州", "南昌", "广州", "福州"}; hm.put(shen, zhou); Set<Map.Entry<String[], String[]>> entrySet = hm.entrySet(); for (Map.Entry<String[], String[]> entry : entrySet) { String[] key = entry.getKey(); String[] value = entry.getValue(); for(int i = 0; i < key.length; i++){ System.out.println(key[i] + "=" + value[i]); } }*/ } } //结果： 福建省=福州 浙江省=杭州 江西省=南昌 广东省=广州 黑龙江省=哈尔滨
1130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
