02_14_Java语音进阶||day14_Java基础小节练习(1-4部分)Collection集合、File类&递归&FileFilter、List集合&Set集合、Map集合

标签：02 Java String System println add 集合 public out

第一部分 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]);
                }
            }*/
        }
    }
    
    //结果：
    福建省=福州
    浙江省=杭州
    江西省=南昌
    广东省=广州
    黑龙江省=哈尔滨

标签：02,Java,String,System,println,add,集合,public,out
From： https://blog.51cto.com/u_15980166/6086809

02_14_Java语音进阶||day14_Java基础小节练习(1-4部分)Collection集合、File类&递归&FileFilter、List集合&Set集合、Map集合

第一部分 Collection集合

1.1 请简述集合框架

1.2 Collection集合：统计元素出现次数

1.3 Collection集合：数组转集合

1.4 Collection集合：集合转数组

1.5 Collection集合：contains()方法使用

1.6 Collection集合：isEmpty()方法的使用

1.7 Collection集合：简述迭代器的实现原理

1.8 Collection集合：返回首次出现索引*

第二部分 File类&递归&FileFilter

2.1 相对路径和绝对路径的使用

2.2 检查文件是否存在,文件的创建：exists，createNewFile

2.3 单级文件夹的创建：mkdir

2.4 多级文件夹的创建：mkdirs

2.5 删除文件和文件夹：delete

2.6 获取文件信息:文件名,文件大小,文件的绝对路径,文件的父路径

2.7 文件夹或文件的判断：isFile(文件)，isDirectory(文件夹)

2.8 文件夹的获取方法

第三部分 List集合&Set集合

3.1 List接口的特点

3.2 hashCode和equals方法

3.3 数据结构

3.4 Comparable和Comparator比较器

3.5 LinkedList方法的使用

3.6 HashSet存储自定义类型

3.7 List集合元素替换

3.8 LinkedHashSet基本使用

3.9 Collections工具类使用

第四部分 Map集合

4.1 Map接口的特点

4.2 Entry键值对对象

4.3 Map接口中的常用方法

4.4 Map接口中的方法

4.5 HashMap存储键是自定义对象值是String

4.6 Map集合的使用（一）

4.7 Map集合的使用（二）

相关文章

赞助商

阅读排行