java集合基础练习题

最新推荐文章于 2024-11-15 18:38:47 发布

奶糖趣多多

最新推荐文章于 2024-11-15 18:38:47 发布

阅读量903

点赞数 33

文章标签： java

本文链接：https://blog.csdn.net/2401_85045690/article/details/141967430

版权

List集合

.ArrayList,LinkedList,Vector三者的相同点与不同点？(“Vector”可百度)【面试题】

共同点：

他们都实现了List接口，意味着他们具有相同的基本操作，如添加、删除、获取元素

有序性和可重复性，他们都是有序的，即插入顺序和迭代顺序相同，都允许存储重复的元素

都可以动态调整大小

不同点:

底层数据结构

ArrayList是基于数组实现的，支持快速的随机访问，但插入和删除涉及元素移动，效率较低

LinkedList底层基于双向链表实现，插入和删除只需要改变相邻节点的引用，因此效率较高，但随机访问元素需要遍历链表，因此效率较低

Vector也基于动态数组实现，但它是线程安全的，因此在多线程环境下性能更好

性能差异：

ArrayList在随机访问和遍历方面表现较好

LinkedList在插入和删除方面表现较好，尤其是列表的开头或结尾

vector由于同步，通常比ArrayList慢。+，但多线程环境中提供线程安全

扩容策略不同：

ArrayList和vector都有容器概念，当添加元素超过当前容量时，会增长自己的存储容量。ArrayList的容量大概按照大约1.5倍的速率增长，vector可以通过构造函数指定增长率，默认是2倍

LinkedList由于其基于链表的实现，不涉及容量的概念

线程安全性不同：

ArrayList和LinkedList都不是线程安全的，如果需要线程安全可以使用Collection类中的静态方法来获取线程安全的容器

vector是线程安全的，效率不是很高

3.List 接口的常用方法有哪些？(增、删、改、查、插、长度、遍历等)

add(E e):
在列表的末尾添加一个元素。

add(int index, E element):
在列表的指定位置插入一个元素。

addAll(Collection<? extends E> c):
将指定集合中的所有元素添加到列表的末尾。

addAll(int index, Collection<? extends E> c):
将指定集合中的所有元素插入到列表的指定位置。

get(int index):
返回列表中指定位置的元素。

remove(int index):
移除列表中指定位置的元素。

remove(Object o):
移除列表中首次出现的指定元素（如果存在）。

contains(Object o):
检查列表中是否包含指定的元素。

indexOf(Object o):
返回列表中首次出现指定元素的索引，如果列表不包含该元素，则返回-1。

lastIndexOf(Object o):
返回列表中最后一次出现指定元素的索引，如果列表不包含该元素，则返回-1。

isEmpty():
检查列表是否为空。

size():
返回列表中的元素数量。

iterator():
返回一个迭代器，用于遍历列表中的元素。

listIterator():
返回一个列表迭代器，它允许以任何方向遍历列表、修改列表，并获取迭代器在列表中的当前位置。

listIterator(int index):
返回一个从指定位置开始的列表迭代器。

subList(int fromIndex, int toIndex):
返回列表中指定范围的视图（从fromIndex到toIndex，不包括toIndex）。

clear():
移除列表中的所有元素。

4.如何使用Iterator和增强for循环遍历List。举例说明

//iterator
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String item = iterator.next();
    System.out.println(item);
}

//增强for
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");

for (String item : list) {
    System.out.println(item);
}

已知有十六支男子足球队参加2008 北京奥运会。

写一个程序，把这16支球队随机分为4个组。采用List集合和随机数

2008 北京奥运会男足参赛国家：

科特迪瓦，阿根廷，澳大利亚，塞尔维亚，荷兰，尼日利亚、日本，美国，中国，新西兰，巴西，比利时，韩国，喀麦隆，洪都拉斯，意大利

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class workDemo1 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("科特迪瓦");
        list.add("阿根廷");
        list.add("澳大利亚");
        list.add("塞尔维亚");
        list.add("荷兰");
        list.add("尼日利亚");
        list.add("日本");
        list.add("美国");
        list.add("中国");
        list.add("新西兰");
        list.add("巴西");
        list.add("比利时");
        list.add("韩国");
        list.add("喀麦隆");
        list.add("洪都拉斯");
        list.add("意大利");
        Random r = new Random();
        List<String> list1 = new ArrayList<>();
        for (int i = 0; i <4; i++) {
            System.out.println("这是第"+(i+1)+"组");
            for (int j = 0; j <4 ; j++) {
                int i1 = r.nextInt(list.size());
                String s = list.get(i1);
                list1.add(s);
                list.remove(s);
            }
            System.out.println(list1);
            list1.clear();
        }
        }
    }

写一个方法reverseList，该函数能够接受一个List，然后把该List 倒序排列。例如：

List list = new ArrayList();

list.add(“Hello”);

list.add(“World”);

list.add(“Learn”); //此时list 为Hello World Learn

reverseList(list); //调用reverseList 方法之后，list 为Learn World Hello

import java.util.ArrayList;
import java.util.List;

public class WorkDemo2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("learn");
        System.out.println(list);
        reverseList(list);
    }

    private static void reverseList(List<String> list) {
        List<String> list1 = new ArrayList<>();
        for (int i= list.size()-1; i>=0; i--) {
            String s = list.get(i);
            list1.add(s);
        }
        System.out.println(list1);
    }
}

有如下Student 对象，

　 private String name;

private int age;

private int score;

private String classNum;

其中，classNum 表示学生的班号，例如“class05”。有如下List List list = new ArrayList();

list.add(new Student(“Tom”, 18, 100, “class05”));

list.add(new Student(“Jerry”, 22, 70, “class04”));

list.add(new Student(“Owen”, 25, 90, “class05”));

list.add(new Student(“Jim”, 30,80 , “class05”));

list.add(new Student(“Steve”, 28, 66, “class06”));

list.add(new Student(“Kevin”, 24, 100, “class04”));

在这个list 的基础上，完成下列要求：

//1）计算所有学生的平均年龄

//2）计算各个班级的平均分

import java.util.ArrayList;
import java.util.List;

public class WorkDemo3 {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("Tom", 18, 100, "class05"));
        list.add(new Student("Jerry", 22, 70, "class04"));
        list.add(new Student("Owen", 25, 90, "class05"));
        list.add(new Student("Jim ", 30, 80, "class05"));
        list.add(new Student("Steve", 28, 66, "class06"));
        list.add(new Student("Kevin", 24, 100, "class04"));
        int numAge = 0;
        for (Student s : list) {
            numAge += s.getAge();
        }
        int ave1 = numAge / list.size();

        System.out.println(ave1);
        int sum4 = 0;
        int sum5 = 0;
        int sum6 = 0;
        int num4 = 0;
        int num5 = 0;
        int num6 = 0;
        for (Student s : list) {
            if (s.getClassNum() == "class04") {

                num4++;
                sum4 += s.getScore();
            }
            if (s.getClassNum() == "class05") {
                num5++;
                sum5 += s.getScore();
            }
            if (s.getClassNum() == "class06") {
                num6++;
                sum6 += s.getScore();
            }
        }
        System.out.println("class04班级的平均分为：" + sum4 / num4);
        System.out.println("class05班级的平均分为：" + sum5 / num5);
        System.out.println("class06班级的平均分为：" + sum6 / num6);
    }
}

Set集合

1.请说明set接口的特点？

无序，不重复，无索引

2.set接口的实现类有哪些？他们的底层实现是什么？分别有什么特点？

set接口的实现类有Hashset和Treeset

HashSet：

底层实现原理：哈希表（散列表）

特点：

1.对集合迭代次序不做保证，存储的元素是无序的

2.允许null元素

3.集合中元素不重复

TreeSet :

底层实现原理：二叉树

特点：

1.满足set接口的特点无序不重复

2.存满的数据可排序

3.不能存储null

其实现本质是TreeMap

请将如下4个字符串数据["aaa"，"bbb"，"ccc"，"ddd"]，依次添加到HashSet集合中，并遍历查看存储结果。（使用增强for循环遍历）

package workDemo1;

import java.util.HashSet;

public class workDemo4 {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();
        set.add("aaa");
        set.add("bbb");
        set.add("ccc");
        set.add("ddd");
        for (String s:set){
            System.out.println(s);
        }
    }
}

//结果
aaa
ccc
bbb
ddd

进程已结束,退出代码0

在List集合内去除重复数字值，要求尽量简单（可借助其他集合！！）

package workDemo1;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class workDemo5 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("11");
        list.add("10");
        list.add("12");
        list.add("11");
        list.add("13");
        list.add("10");
        list.add("15");
        System.out.println(list);

        Set<String> set = new HashSet<>();

        set.addAll(list);
       for (String s:set){

       }
        System.out.println(set);
    }
}

2019年1月份的世界编程语言排行榜从高到低依次如下： Java、C、Python、C++、Visual Basic .NET、JavaScript... 请将以上语言名称作为字符串元素，按顺序存入set集合中，并遍历查看。要求存储和遍历的顺序保持一致。

import java.util.LinkedHashSet;

public class workDemo6 {
    public static void main(String[] args) {
        LinkedHashSet<String> set = new LinkedHashSet<>();
        set.add("Java");
        set.add("C");
        set.add("Python");
        set.add("C++、");
        set.add("Visual Basic .NET");
        set.add("JavaScript");
        for (String s:set){
            System.out.println(s);
        }
    }
}

现有若干图书信息（包含名称title、作者author、定价price）需要存储到set集合中，保证集合中无重复元素，并遍历查看。可以认为所有信息都相同的图书为重复数据。

import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
public class WorkDemo {
    public static void main(String[] args) {
        LinkedHashSet<Book> set = new LinkedHashSet<>();

        Book book1 = new Book("西游记", "吴承恩", "108");
        Book book2 = new Book("水浒传","施耐庵","121");
        Book book3 = new Book("红楼梦","曹雪芹","105");
        Book book4 = new Book("三国演义","罗贯中","132");
        Book book5 = new Book("西游记","吴承恩","108");
        set.add(book1);
        set.add(book2);
        set.add(book3);
        set.add(book4);
        set.add(book5);

        Iterator<Book> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

    }
}

在某次考试中，学生的成绩信息如下（公有属性）：姓名(String) 年龄（int）成绩(int): Tom 20 90； Jerry 22 95； John 20 100； Lily 22 100 ；Lucy 22 90； Kevin 22 90 请分别用Comparable和Comparator两个接口对以上同学的成绩做降序排序，如果成绩一样，那在成绩排序的基础上按照年龄由小到大排序，成绩和年龄都一样，则按照姓名的字典顺序排序。

package workDemo3;

public class Student implements Comparable<Student> {
    String name;
    int age;
    int score;

    public Student() {
    }

    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    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;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }


    @Override
    public int compareTo(Student s) {
        int num=s.score-this.score;
       int num1= num==0?this.age-s.age:num;
       int num2= num==0?this.name.compareTo(s.name):num1;
        return num2;
    }
}


import java.util.TreeSet;

public class Test1 {
    public static void main(String[] args) {
        TreeSet<Student> set = new TreeSet<>() ;

        Student stu1 = new Student("Tom",20,90);
        Student stu2 = new Student("Jerry",22,90);
        Student stu3 = new Student("John",20,100);
        Student stu4 = new Student("Lily",22,100);
        Student stu5 = new Student("Lucy",22,95);
        Student stu6 = new Student("Kevin",22,90);
        set.add(stu1);
        set.add(stu2);
        set.add(stu3);
        set.add(stu4);
        set.add(stu5);
        set.add(stu6);
    for (Student s:set){
        System.out.println(s.getName()+","+s.getAge()+","+s.getScore());
    }
    }
}

    //需求：编写一个程序，获取10个1-20之间的随机数，要求随机数不能重复，并在控制台输出
    /*思路：
    1.创建Set集合对象
    2.创建随机数对象
    3.判断集合长度是不是小于10
      是：产生一个随机数添加到集合
      回到3继续
    4.遍历集合

import java.util.Random;
import java.util.Set;
import java.util.TreeSet;

public class SetDemo1 {
  
    public static void main(String[] args) {
        //HashSet不排序
      //  Set<Integer> set = new HashSet<Integer>();
        //TreeSet可排序
        Set<Integer> set = new TreeSet<>();
        Random r = new Random();
        while (set.size()<10){
            int num = r.nextInt(20)+1;
            set.add(num);
        }
        for (Integer i:set){
            System.out.println(i);
        }
    }
}

/*
  需求
  键盘录入一个字符串，要求统计字符中每个字符串出现的次数
  举例：键盘录入“aababcabcdabcde”在控制台输出“a(5)b(4)c(3)d(2)e(1)”

  思路
  1.键盘录入一个字符串
  2.创建HashMap集合，键是Character,值是Integer
  3.遍历字符串得到每一个字符
  4.得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
       如果返回值是null：说明该字符在HashMap集合中不存在，就把该字符作为键，1作为值存储
       如果返回值不是null，说明该字符在HashMap集合中不存在，把该值加1，然后重新存储该字符和对应的值
  5.遍历HashMap集合，得到键和值，按照要求进行拼接
  6.输出结果
   */

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;

public class HashMapDemo1 {
   
   public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = sc.nextLine();

        //创建HashMap集合
        HashMap<Character, Integer> hm = new HashMap<Character, Integer>();

        for (int i = 0; i < line.length(); i++) {
            char key = line.charAt(i);
            Integer value = hm.get(key);
            if(value==null){
                hm.put(key,1);
            }else{
                value++;
                hm.put(key,value);
            }
        }
        StringBuilder sb = new StringBuilder();
        Set<Character> keySet = hm.keySet();
        for(Character key:keySet){
            Integer value = hm.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String s = sb.toString();
        System.out.println(s);
    }
}