四川盐亭网站制作公司

【Java基础】·集合习题详解-创新互联

写在前面

  Hello大家好， 我是【麟-小白】，一位软件工程专业的学生，喜好计算机知识。希望大家能够一起学习进步呀！本人是一名在读大学生，专业水平有限，如发现错误或不足之处，请多多指正！谢谢大家！！！

成都创新互联公司主要从事成都网站制作、成都做网站、网页设计、企业做网站、公司建网站等业务。立足成都服务弋阳,十年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18980820575

  如果小哥哥小姐姐们对我的文章感兴趣，请不要吝啬你们的小手，多多点赞加关注呀！❤❤❤ 爱你们！！！

目录

写在前面

Collection 和 Collections的区别

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

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

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

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

HashMap和Hashtable的区别

ArrayList和Vector的区别

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

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

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

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

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

创建Car类，包含name，price属性，构造器等方法，创建测试类，在main方法中创建Set接口的实现类，添加5个以上的Car对象，遍历集合元素，验证重复元素是否过滤了；如果没有过滤，实现过滤功能；把每个小车的price降10000元，再遍历，查看price是否已改变

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

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

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

1)添加几条信息

2)列出所有的员工姓名

3)列出所有员工姓名及其工资

4)删除名叫“Tom”的员工信息

5)输出Jack的工资，并将其工资加1000元(通过取值实现)

6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)

封装一个新闻类，包含标题、作者、新闻内容和发布时间，新闻标题如下：

按要求完成如下操作 

按要求完成如下操作

以下代码的运行结果？

结语

【集合精讲】

一文带你深入理解【Java基础】· Java集合（下）

一文带你深入理解【Java基础】· Java集合（中）

一文带你深入理解【Java基础】· Java集合（上）

Collection 和 Collections的区别

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

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

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

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

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

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

答： List，Set是，Map不是

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

答：不对，有相同的hash code

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

答：ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

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算法都大概一样，所以性能不会有很大的差异。

ArrayList和Vector的区别

答：就ArrayList与Vector主要从二方面来说.

一.同步性:Vector是线程安全的，也就是说是同步的，而ArrayList是线程序不安全的，不是同步的

二.数据增长:当需要增长时,Vector默认增长为原来的2培，而ArrayList却是原来的1.5倍

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

答：最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector，它们是可变大小的列表，比较适合构建、存储和操作任何类型对象的元素列表。 List 适用于按数值索引访问元素的情形。

Map 提供了一个更通用的元素存储方法。 Map 集合类用于存储元素对（称作"键"和"值"），其中每个键映射到一个值。

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

public class Test {
    public static void main(String[] args) {
        //引用一个Set集合实现类
       Set set = new HashSet();
       //添加单个元素
       set.add("哈");
       set.add("士");
       set.add("奇");
       //添加另一个Set集合
       Set S = new HashSet();
       //将一个集合的所有元素添加到另一个集合
       S.addAll(set);
       //移除指定元素
       S.remove("哈");
       //判断集合中是否包含另一个元素
       System.out.println("集合中是否含有“哈”：" + S.contains("哈"));
       //判断是否为空
       System.out.println("集合是否为空：" + S.isEmpty());
       //清除集合
       S.clear();
       //返回集合元素个数
       System.out.println(S.size());
   }
}

创建Set接口的实现类，添加10个以上的元素，通过Iterator遍历此集合元素。
public static void main(String[] args) {
    //创建Set接口的实现类
    Set set1 = new HashSet();

    //添加10个以上的元素
    set1.add(22);
    set1.add(2);
    set1.add(55);
    set1.add(78);
    set1.add(5);
    set1.add(15);
    set1.add(7);
    set1.add(30);
    set1.add(9);
    set1.add(70);
    set1.add(11);

    //通过Iterator遍历此集合元素
    Iterator iterator = set1.iterator();
    while(iterator.hasNext()){
        System.out.print(iterator.next() + " ");
    }
}

创建Set接口的实现类，添加10个以上的元素，通过foreach遍历此集合元素。
public class SetTest {
    @Test
    public void test1() {
        HashSetobjects = new HashSet<>();
        objects.add("123");
        objects.add("drtg");
        objects.add("25");
        objects.add("srthy");
        objects.add("zxc");
        objects.add("tdfh");
        objects.add("453");
        objects.add("SDGFrdsh");
        objects.add("zx254c");
        objects.add("sdGFSD");
        objects.add("578585");

        for (Object obj : objects) {
            System.out.println(obj);
        }
    }
}
创建Set接口的实现类，添加10个以上的元素，要求能够排序。
@Test
    public void test2() {
        TreeSetset1 = new TreeSet<>();
        set1.add(123);
        set1.add(456);
        set1.add(789);
        set1.add("asd");
        set1.add("zxc");
        set1.add("sdfg");
        set1.add("qwe");
        set1.add(856);
        set1.add(649815);
        set1.add(4563);
        set1.add("dafdsgf");
        set1.add(65);
        set1.add(13);
        set1.add(63);

        for (Object obj : set1) {
            System.out.println(obj);
        }
    }
创建Car类，包含name，price属性，构造器等方法，创建测试类，在main方法中创建Set接口的实现类，添加5个以上的Car对象，遍历集合元素，验证重复元素是否过滤了；如果没有过滤，实现过滤功能；把每个小车的price降10000元，再遍历，查看price是否已改变
car
public class Car {
    //创建Car类，包含name，price属性，构造器等方法

    private String name;

    private int price;

    public Car() {
    }

    public Car(String name, int price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "name=" + name +
                "  price=" + price;
    }
}
测试类：
public class CarTest {
    public static void main(String[] args) {
        //创建测试类，在main方法中创建Set接口的实现类
        Setset = new TreeSet<>(new Comparator() {
            @Override
            public int compare(Car o1, Car o2) {
                int num = o1.getName().compareTo(o2.getName());
                int num1 = num == 0 ? o1.getPrice() - o2.getPrice() : num;
                return num1;
            }
        });

        //添加5个以上的Car对象
        set.add(new Car("沃尔沃",250000));
        set.add(new Car("大众",150000));
        set.add(new Car("凯迪拉克",350000));
        set.add(new Car("奥迪",550000));
        set.add(new Car("雷克萨斯",950000));
        set.add(new Car("雷克萨斯",950000));

        //遍历集合元素，验证重复元素是否过滤了，如果没有过滤，实现过滤功能
        for (Car car : set){
            System.out.println(car);
        }
        System.out.println("------------------------------");

        //把每个小车的price降10000元,再遍历，查看price是否已改变
        for (Car car : set){
            car.setPrice(car.getPrice()-10000);
            System.out.println(car);
        }
    }
}
创建ArrayList实例化对象，添加10个以上的元素，在2号位插入一个元素，获得5号位元素，删除6号位元素，修改7号位的元素；
@Test
    public void Test3() {
        ArrayListlist = new ArrayList<>();
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(123);
        list.add(2, 365);
        System.out.println(list.get(5));
        list.remove(6);
        list.set(7, 666);
        Iteratoriterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
    }
定义一个Map接口类型的变量，引用一个实现类，添加键值对，判断集合中是否包含某一key值，通过某一key值得到value值，通过某一key删除键值对，把另一个map集合添加到此map集合，判断是否为空，清除集合，返回集合里元素的个数等常用操作。通过两种方法遍历map集合
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

    @Test
    public void test4() {
        // 定义一个Map接口类型的变量，引用一个实现类
        HashMaphashMap = new HashMap();

        //添加键值对
        hashMap.put("123", "你好");
        hashMap.put("蜂蜜", "柚子茶");
        hashMap.put("Lisa", "Rose");

        //判断集合中是否包含某一key值
        System.out.println(hashMap.containsKey("蜂蜜"));//ture

        //通过某一key值得到value值
        System.out.println(hashMap.get("123"));//你好

        //通过某一key删除键值对
        hashMap.remove("蜂蜜");
        System.out.println(hashMap); //{123=你好, Lisa=Rose}

        //把另一个map集合添加到此map集合
        HashMaphashMap1 = new HashMap();
        hashMap1.putAll(hashMap);

        //判断是否为空
        System.out.println(hashMap.isEmpty());//false

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

        //返回集合里元素的个数
        System.out.println(hashMap.size()); //0

        //通过两种方法遍历上题中的map集合
        //方式一
        SetkeySet = hashMap1.keySet();
        for (String key : keySet) {
            String value = hashMap1.get(key);
            System.out.println("key:" + key + " , " + "value:" + value);
        }
        System.out.println("-------------------------");
        //方式二
        Set>entrySet = hashMap1.entrySet();
        for (Map.Entryme : entrySet) {
            String key = me.getKey();
            String value = me.getValue();
            System.out.println("key:" + key + " , " + "value:" + value);
        }
    }
使用Map接口的实现类完成员工工资(姓名--工资)的摸拟： 
1)添加几条信息 
2)列出所有的员工姓名 
3)列出所有员工姓名及其工资 
4)删除名叫“Tom”的员工信息 
5)输出Jack的工资，并将其工资加1000元(通过取值实现) 
6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)
@Test
    public void test5() {
        HashMaphashMap = new HashMap();

        //1)添加几条信息
        hashMap.put("Pamela", 5000);
        hashMap.put("Jack", 4800);
        hashMap.put("Tom", 6100);
        hashMap.put("Lee", 800);
        hashMap.put("Lara", 500);

        //2)列出所有的员工姓名
        SetkeySet = hashMap.keySet();
        System.out.println("员工姓名：" + keySet);

        //3)列出所有员工姓名及其工资
        for (String key : keySet) {
            //5)输出Jack的工资，并将其工资加1000元(通过取值实现)
            if (hashMap.get(key).equals("Jack")) {
                int value = hashMap.get(key) + 1000;
                hashMap.put("Jack", value);
            }

            //6)将所有工资低于1000元的员工的工资上涨20%(通过取值实现)
            if (hashMap.get(key)< 1000) {
                double value = (hashMap.get(key) + (hashMap.get(key) * 0.2));
                hashMap.put(key, (int) value);
            }
            int value = hashMap.get(key);
            System.out.println("姓名：" + key + " , " + "工资：" + value);
        }

        //4)删除名叫“Tom”的员工信息
        hashMap.remove("Tome");
    }
封装一个新闻类，包含标题、作者、新闻内容和发布时间，新闻标题如下：
新闻一：中国多地遭雾霾笼罩空气质量再成热议话题
新闻二：民进党台北举行“火大游行”
新闻三：春节临近北京“卖房热”
新闻四：春节临近北京“卖房热”
完成如下要求（共50分，每小题10分）：
1）完成对新闻类的设计，要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
2）要求打印新闻对象时，直接打印新闻标题；
3）要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果。
4）将新闻对象存入HashSet集合中，并且遍历集合，打印新闻类对象；
5）打印集合中新闻数量。
public class Journalism {
    //封装一个新闻类，包含标题、作者、新闻内容和发布时间，

    private String title;

    private String author;

    private String details;

    private Date date;

    public Journalism() {
    }

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

    public String getTitle() {
        return title;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getDetails() {
        return details;
    }

    public void setDetails(String details) {
        this.details = details;
    }

    public Date getDate() {
        return date;
    }

    public void setDate(Date date) {
        this.date = date;
    }

    @Override
    public String toString() {
        return "标题：" + title +
                "\n作者：" + author +
                "\n内容：" + details +
                "\n发布时间：" + date ;
    }

    //要求使用equals方法比较新闻时，只要标题相同，就认为是同一新闻

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Journalism that = (Journalism) o;

        return title != null ? title.equals(that.title) : that.title == null;
    }

    @Override
    public int hashCode() {
        return title != null ? title.hashCode() : 0;
    }
}
public class Test {
    public static void main(String[] args) {
        //创建HashSet集合对象
        Setset = new HashSet();

        //要求在初始化新闻类对象时 ，通过构造传参的形式对新闻标题赋值，并要求实例化四个对象，标题内容如题。
        Journalism journalism1 = new Journalism("中国多地遭雾霾笼罩空气质量再成热议话题");
        Journalism journalism2 = new Journalism("民进党台北举行“火大游行“");
        Journalism journalism3 = new Journalism("春节临近北京“卖房热”");
        Journalism journalism4 = new Journalism("春节临近北京“卖房热”");

        //将新闻对象存入HashSet集合中
        set.add(journalism1);
        set.add(journalism2);
        set.add(journalism3);
        set.add(journalism4);

        //要求打印新闻对象时，直接打印新闻标题；
        for (Journalism journalism : set){
            System.out.println(journalism);
            System.out.println("------------------------");
        }

        //只要标题相同，就认为是同一新闻，请输出新闻一与新闻二的比较结果，新闻三与新闻四的比较结果
        System.out.println("新闻一与新闻二的比较结果:"+journalism1.equals(journalism2));
        System.out.println("新闻三与新闻四的比较结果:"+journalism3.equals(journalism4));

        //打印集合中新闻数量
        System.out.println("集合中新闻数量:"+set.size());
    }
}
按要求完成如下操作 
  1. 生成10个随机数，值在100到200之间；
  2. 将这十个数存入HashSet集合中（有可能集合的长度小于10）。
  3. 将这个HashSet集合转换成ArrayList集合
  4. 重新为ArrayList集合排序，按照从小到大的顺序；
  5. 使用foreach遍历集合；
@Test
    public void test4() {
        HashSethashset = new HashSet();
        Random random = new Random();

        for (int i = 0; i< 10; i++) {
            int j = random.nextInt(100) + 101;
            hashset.add(j);
        }
        System.out.println(hashset);

        ArrayListlist = new ArrayList(hashset);
        list.sort(Comparator.naturalOrder());
        list.forEach(integer ->{
            System.out.print(integer + " ");
        });
    }
按要求完成如下操作
1 ）封装一个汽车类，包含String  name、int  speed属性，在测试类中实例化三个对象：c1，c2，c3，分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
2 ）使用Map集合对象m1将这三个汽车类对象保存成key，然后将int型的汽车价钱作为值保存在m1的value中，上述三款汽车分别对应的价钱是10000,500000,2000000
3 ）遍历m1的键，打印name属性
4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
@Test
    public void test6() {
        //在测试类中实例化三个对象：c1，c2，c3，
        //分别设置name为：“奥拓”，“宝马”，“奔驰”，速度分别设置为：100,200,300
        Car c1 = new Car("奥拓", 100);
        Car c2 = new Car("宝马", 200);
        Car c3 = new Car("奔驰", 300);

        //2 ）使用Map集合对象m1将这三个汽车类对象保存成key
        HashMaphashMap = new HashMap<>();

        //然后将int型的汽车价钱作为值保存在m1的value中,上述三款汽车分别对应的价钱是10000,500000,2000000
        hashMap.put(c1, 10000);
        hashMap.put(c2, 500000);
        hashMap.put(c3, 2000000);

        //3 ）遍历m1的键，打印name属性
        SetkeySet = hashMap.keySet();
        int i = 1;
        for (Car car : keySet) {
            System.out.print("car" + i++ + "name:" + car.getName() + "   ");
        }

        for (Car car : keySet) {
            //4 ）通过合适的方法，求出m1中“宝马”的价格，并打印结果；
            if (car.getName().equals("宝马")) {
                int price = hashMap.get(car);
                System.out.println("\n宝马价格为：" + price);
            }
            //5 ）经过折旧，所有汽车都降价到原来的80%，请打印降价后“宝马”的价格
            double price1 = hashMap.get(car) - (hashMap.get(car) * 0.2);
            hashMap.put(car, (int) price1);
        }
        //请打印降价后“宝马”的价格
        for (Car car : keySet) {
            if (car.getName().equals("宝马")) {
                int price = hashMap.get(car);
                System.out.println("宝马价格为：" + price);
            }
        }
    }
以下代码的运行结果？
public static void main(String[] args) {
    Integer[] datas = {1,2,3,4,5};
    Listlist = Arrays.asList(datas);
    list.add(5);
    System.out.println(list.size());
}
运行异常，不允许添加元素
 结语
本人会持续更新文章的哦！希望大家一键三连，你们的鼓励就是作者不断更新的动力
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧
                

                网站名称：【Java基础】·集合习题详解-创新互联                

                当前URL：http://scyanting.com/article/coogpc.html
            
        
        

            
其他资讯