JavaSE集合练习题

简答

1.Collection 和 Collections的区别

解：Collection是集合类的上级接口，继承于他的接口主要有 Set 和 List

Collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作

2.Set里的元素是不能重复的，那么用什么方法来区分重复与否呢? 是用==还是equals()? 它们有何区别

解：Set里的元素是不能重复的，用equals()方法判读两个Set是否相等

equals()和==方法决定引用值是否指向同一对象equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值

3.List, Set, Map是否继承自Collection接口

解：List，Set 继承自 Collection 接口

Map不是继承Collection 接口

4.两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对

解：不对，有相同的 hash code

5.说出ArrayList,Vector, LinkedList的存储性能和特性

解：共同点 ：三个类都是实现了 List接口，存储数据的特点相同：存储有序的，可重复的数据
    区别： ArrayList ：作为 List接口的主要实现类；线程不安全的，效率高；底层使用 Object[] elementData 存储
           LinkedList：对于频繁的插入，删除操作，使用此类效率比 ArrayList高；底层使用双向链表存储
           Vector ：作为 List接口的古老实现类；线程安全的，效率低；底层使用 Object[] elementData 存储

6.HashMap和Hashtable的区别

1.HashMap与Hashtable都实现了Map接口。由于HashMap的非线程安全性，效率上可能高于Hashtable。Hashtable的方法是
Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap 就必须
为之提供外同步
2. HashMap允许将null作为一个entry的key或者value，而Hashtable不允许
3.HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解
4.Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现
5.Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异

7.你所知道的集合类都有哪些？主要方法？

最常用的集合类是 List 和 Map。 
List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 
List 适用于按数值索引访问元素的情形。 
Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值

编程

1.定义一个Collection接口类型的变量，引用一个Set集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作

注：Set接口中没有额外定义新的方法，使用的都是 Collection 中声明的方法

package com.atguigu.com;

import java.util.Collection;
import java.util.HashSet;

public class exer1 {
    public static void main(String[] args) {
        Collection coll1 = new HashSet();
        //1.添加单个元素
        coll1.add(123);
        coll1.add("九十九");
        coll1.add(12.56);


        //2.添加另一个集合
        Collection coll2 = new HashSet();
        coll2.add("coll2");
        coll2.add(false);

        coll1.addAll(coll2);

        //3.删除元素
        coll1.remove(12.56);

        //4.判断集合中是否包含一个元素
        coll1.contains(false);

        //5.判断是否为空
        coll1.isEmpty();

        //6.清除集合
        coll1.clear();

        //7.返回集合里元素的个数
        coll1.size();
    }
}

2.创建Set接口的实现类，添加10个以上的元素，通过Iterator遍历此集合元素

package com.atguigu.com;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class exer2 {
    public static void main(String[] args) {
        Set set = new HashSet();

        //添加元素
        set.add(12);
        set.add(12.4);
        set.add('c');
        set.add(true);
        set.add(false);
        set.add("九十八");
        set.add("学而不思则罔");
        set.add("思而不学则殆");
        set.add("温故而知新");
        set.add("可以为师矣");

        //使用Iterator 遍历此集合
        Iterator iterator = set.iterator();
        //搭配hasNext()和next()方法
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

c
12.4
false
九十八
学而不思则罔
温故而知新
可以为师矣
思而不学则殆
12
true

3.创建Set接口的实现类，添加10个以上的元素，通过foreach遍历此集合元素

package com.atguigu.com;
import java.util.HashSet;

import java.util.Set;
public class exer3 {
    public static void main(String[] args) {
        Set set = new HashSet();

        //添加元素
        set.add(12);
        set.add(12.4);
        set.add('c');
        set.add(true);
        set.add(false);
        set.add("九十八");
        set.add("学而不思则罔");
        set.add("思而不学则殆");
        set.add("温故而知新");
        set.add("可以为师矣");

        //使用foreach来遍历集合
        //for(集合元素的类型 局部变量 : 集合对象){}
        for(Object i : set){
            System.out.println(i);
        }
    }
}

c
12.4
false
九十八
学而不思则罔
温故而知新
可以为师矣
思而不学则殆
12
true

4.创建Set接口的实现类，添加10个以上的元素，要求能够排序

注：向 TreeSet 中添加的数据，要求是相同类的对象

package com.atguigu.com;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class exer4 {
    public static void main(String[] args) {
        //定制排序
        Comparator com = new Comparator() {
            //对字符串进行排序 从大到小
            @Override
            public int compare(Object o1, Object o2) {
                if(o1 instanceof String && o2 instanceof String){
                    String str1 = (String)o1;
                    String str2 = (String)o2;
                    return -str1.compareTo(str2);
                }else{
                    throw new RuntimeException("输入数据类型不匹配！");
                }
            }
        };

        TreeSet tree = new TreeSet(com);

        tree.add("abcd");
        tree.add("cdac");
        tree.add("zsdc");

        Iterator iterator = tree.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

zsdc
cdac
abcd

记录：java 比较器 comparable 和 comparator 需要复习，一调用比较器就犯迷糊

5.定义一个Collection接口类型的变量，引用一个List集合的实现类，实现添加单个元素，添加另一个集合，删除元素，判断集合中是否包含一个元素，判断是否为空，清除集合，返回集合里元素的个数等常用操作

package com.atguigu.com;

import java.util.ArrayList;
import java.util.Collection;

public class exer5 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        //1.添加单个元素 可重复
        list.add(123);
        list.add(456);
        list.add(false);
        list.add(456);

        //2.添加另一个集合
        ArrayList list1 = new ArrayList();
        list1.add(12.4);
        list1.add(34.6);

        list.add(list1);//将list1作为一个元素添加到list中
        list.addAll(list1);//将list1中的每个元素迭代添加到list中

        //3.删除元素
        //3.1 按照元素删除
        list.remove(false);
        //3.2按照索引删除
        list.remove(2);

        //4.判断集合中是否包含一个元素
        list.contains(true);

        //5.判断是否为空
        list.isEmpty();

        //6.清除集合
        list.clear();

        //7.返回集合里元素的个数
        list.size();

    }
}

6.创建ArrayList实例化对象，添加10个以上的元素，在2号位插入一个元素，获得5号位元素，删除6号位元素，修改7号位的元素；

package com.atguigu.com;

import java.util.ArrayList;

public class exer6 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        //演示 采用for循环迭代添加元素
        for(int i = 0;i < 10;i++){
            list.add(i);
        }

        //在2号位插入一个元素  2号位默认为索引
        list.add(2,"insert");

        //获得5号位元素
        list.get(5);

        //删除6号位元素 idea中可以显示是索引还是元素值
        list.remove(6);

        //修改7号位的元素
        list.set(7,"new");
    }
}

7.通过四种方法遍历上题中的集合

package com.atguigu.com;

import java.util.ArrayList;
import java.util.Iterator;

public class exer7 {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();

        //演示 采用for循环迭代添加元素
        for(int i = 0;i < 10;i++){
            list.add(i);
        }

        //在2号位插入一个元素  2号位默认为索引
        list.add(2,"insert");

        //获得5号位元素
        list.get(5);

        //删除6号位元素 idea中可以显示是索引还是元素值
        list.remove(6);

        //修改7号位的元素
        list.set(7,"new");

        //使用iterator 进行遍历
        Iterator iterator = list.iterator();
        while(iterator.hasNext()){
            System.out.print(iterator.next() + " ");
        }
        System.out.println();
        //使用foreach 进行遍历
        for(Object obj:list){
            System.out.print(obj + " ");
        }
        System.out.println();
        //使用for进行遍历
        for(int i = 0; i < list.size();i++){
            System.out.print(list.get(i) + " ");
        }
        System.out.println();
        //使用Lambda表达式的forEach  之前没用过这种结构
        list.forEach(item -> System.out.print(item + " "));
    }
}

0 1 insert 2 3 4 6 new 8 9 
0 1 insert 2 3 4 6 new 8 9 
0 1 insert 2 3 4 6 new 8 9 
0 1 insert 2 3 4 6 new 8 9 

8.按要求实现下列问题
1)封装一个新闻类，包含标题和内容属性，提供get、set方法，重写toString方法，打印对象时只打印标题；

2)只提供一个带参数的构造器，实例化对象时，只初始化标题；并且实例化两个对象：
新闻一：中国多地遭雾霾笼罩空气质量再成热议话题
新闻二：春节临近北京“卖房热”

3)将新闻对象添加到ArrayList集合中，并且使用ListIterator倒序遍历；

4)在遍历集合过程中，对新闻标题进行处理，超过15字的只保留前14个，然后在后边加“…”

5)在控制台打印遍历出经过处理的新闻标题；

package com.atguigu.com;

public class News {

    private String title;
    private String content;

    public News(String title){
        this.title = title;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    @Override
    public String toString() {
        return "News{" +
                "title='" + title + '\'' +
                '}';
    }
}

package com.atguigu.com;

import java.util.ArrayList;
import java.util.Collection;
import java.util.ListIterator;

public class NewsTest {
    public static void main(String[] args) {
        News n1 = new News("中国多地遭雾霾笼罩空气质量再成热议话题");
        News n2 = new News("春节临近北京\"卖房热\"");

        ArrayList list = new ArrayList();
        list.add(n1);
        list.add(n2);

        ListIterator iterator = list.listIterator();
        //指针位于开头
        while(iterator.hasNext()) {
            //不断循环 将指针位于结尾
            iterator.next();
        }

        //逆向遍历
        while(iterator.hasPrevious()) {
            Object obj = iterator.previous();
            News n = (News) obj;
            String title = n.getTitle();
            if(title.length() > 15){
                System.out.println(title.substring(0,15) + "...");
            }else{
                System.out.println(title);
            }
        }
    }
}

9 定义一个Map接口类型的变量，引用一个实现类，添加键值对，判断集合中是否包含某一key值，通过某一key值得到value值，通过某一key删除键值对，把另一个map集合添加到此map集合，判断是否为空，清除集合，返回集合里元素的个数等常用操作

package com.atguigu.com;

import java.util.HashMap;

public class exer9 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        //添加键值对
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);

        //判断集合中是否包含某一key值
        map.containsKey("CC");

        //通过某一key值得到value值
        map.get("AA");

        //通过某一key删除键值对
        map.remove("BB");

        //把另一个map集合添加到此map集合
        HashMap map1 = new HashMap();
        map1.put("DD",452);
        map1.put("EE",123);

        map.putAll(map1);

        //判断是否为空
        map.isEmpty();

        //清除集合
        map.clear();

        //返回集合里元素的个数
        map.size();
    }
}

10.通过两种方法遍历上题中的map集合

package com.atguigu.com;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class exer10 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        //添加键值对
        map.put("AA",123);
        map.put(45,123);
        map.put("BB",56);

        //判断集合中是否包含某一key值
        map.containsKey("CC");

        //通过某一key值得到value值
        map.get("AA");

        //通过某一key删除键值对
        map.remove("BB");

        //把另一个map集合添加到此map集合
        HashMap map1 = new HashMap();
        map1.put("DD",452);
        map1.put("EE",123);

        map.putAll(map1);

        //判断是否为空
        map.isEmpty();

        //清除集合
        //map.clear();

        //返回集合里元素的个数
        map.size();

        //遍历集合
        //方式一：entrySet()
        Set entrySet = map.entrySet();
        Iterator iterator = entrySet.iterator();
        while (iterator.hasNext()){
            Object obj = iterator.next();
            //entrySet 集合中的元素都是entry
            Map.Entry entry = (Map.Entry) obj;
            System.out.println(entry.getKey() +
                    "----->" + entry.getValue());
        }
        System.out.println("---------------");

        //方式二
        Set keySet = map.keySet();
        Iterator iterator1 = keySet.iterator();
        while (iterator1.hasNext()){
            Object key = iterator1.next();
            Object value = map.get(key);
            System.out.println(key +
                    "----->" + value);
        }
    }
}

11.使用Map接口的实现类完成员工工资(姓名–工资)的摸拟：

1)添加几条信息
2)列出所有的员工姓名
3列出所有员工姓名及其工资
4)删除名叫“Tom”的员工信息
5)输出Jack的工资，并将其工资加1000元(通过取值实现)
6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)

package com.atguigu.com;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;

public class exer11 {
    public static void main(String[] args) {
        HashMap map = new HashMap();
        //添加数据
        map.put("张三",500);
        map.put("李四",600);
        map.put("Tom",6000);
        map.put("王五",7000);
        map.put("jack",8000);

        //列出所有的员工姓名
        Set nameSet = map.keySet();
        Iterator iterator = nameSet.iterator();
        while(iterator.hasNext()){
            System.out.println(iterator.next());
        }

        System.out.println("***************");
        //列出所有员工姓名及其工资
        Iterator iterator1 = nameSet.iterator();
        while (iterator1.hasNext()){
            Object name = iterator1.next();
            Object salary = map.get(name);
            System.out.println(name +
                    "----->" + salary);
        }

        //删除名叫""Tom"”"的员工信息
        map.remove("Tom");

        //输出Jack的工资,并将其工资加1000元(通过取值实现)
        double salaryJack = (double)map.get("jack");
        System.out.println(salaryJack);
        map.put("jack",salaryJack + 1000);
        
        Set nameSet2 = map.keySet();
        Iterator iterator2 = nameSet2.iterator();
        while(iterator2.hasNext()){
            Object name = iterator2.next();
            double salary = (double)map.get(name);
            if(salary < 1000){
                map.put(name,salary * 1.2);
            }
        }
    }
}

参考文献

链接: B站尚硅谷宋红康Java.