集合的细节

最新推荐文章于 2022-08-03 00:42:59 发布

学无止路

最新推荐文章于 2022-08-03 00:42:59 发布

阅读量660

点赞数

分类专栏： JavaSe 文章标签： java 数据结构链表

本文链接：https://blog.csdn.net/weixin_40055163/article/details/120285135

版权

JavaSe 专栏收录该内容

58 篇文章 16 订阅

订阅专栏

集合

概念：将多个对象集中整合在一个对象中，用来存储对象的容器，与数组的作用一样，但更加便捷。
位置：Java.util包中。

1 Collection 接口

作用：存储对象。
常用方法：

方法名	作用
add(Object obj)	添加一个对象
remove(Object obj)	删除一个对象
size()	返回有效元素个数
contains(Object o)	判断集合中是否有与o相同的元素
clear()	清空集合
isEmpty()	判断是否为空集合
toArray()	返回对象数组

2 List接口

Collection接口的子接口。

特点：有序、有下标、元素可重复。
常用方法：

方法名	作用
add(int index , E element）	将元素添加到指定index位置
get(int index )	返回index位置的元素
remove(int index )	移除index位置的
set(int index , E element ）	更换index位置的元素

备注：E 默认就是Object，使用set方法时注意，如果index位置没有元素，则出现异常。
演示的代码如下：

package com.txw.test;

import java.util.LinkedList;
import java.util.List;
public class TestList {
    public static void main(String[] args) {
        List list = new LinkedList();	// Object[] objs = new Object[10];
        // 存放元素
        list.add("阿森");	// objs[0] = "阿森";
        list.add("阿云");	// objs[1] = "阿云"
        list.add("wang");
        list.add("大黄");
        Object obj1 = list.get(0);	// Object obj1 = objs[0];
        // System.out.println(obj1);
        // System.out.println( list.get(1) );	// System.out.println(objs[1]);
        // 打印集合有效元素个数
        // System.out.println(list.size());		// objs.length
        // 移除下标为2的元素，下标为3的元素向前移动
        // list.remove(2);
        // 打印有效元素个数
       // System.out.println(list.size());//objs.length
        // 获取下标我
        // System.out.println(list.get(2));
        // 遍历集合元素
        /*
        for(int i=0; i<list.size(); i++){
            // 利用get方法配合下标获取元素
            Object obj = list.get(i);
            System.out.println( obj );
        }
        */
    }
}

3 实现类

3.1 ArrayList【重点】

特点：使用数组存储元素，查询效率高，增删效率低。
操作速度快，线程不安全。

3.2 Vector【没有用】

特点：使用数组存储元素，查询效率高，增删效率低。
操作速度慢，线程安全。

3.3 LinkedList【了解】

特点：使用链表存储元素，查询效率低，增删效率高。
操作速度快，线程不安全。

4 遍历集合元素

4.1 使用for循环遍历。

编程套路：

for(int i=0; i<集合名.size(); i++){
    // 利用get方法配合下标获取元素
    Object obj = 集合名.get( i );
}

演示的代码如下：

List list = new ArrayList();
// 遍历集合
for(int i=0; i<list.size(); i++){
    // 利用get方法配合下标获取元素
    Object obj = list.get(i);
    
}

4.2 forEach遍历

JDK5统一对所有容器的遍历方式。

编程套路：

for(声明变量 : 集合名){
    
}

注意：声明的变量类型要与集合中的元素类型一致。
演示：forEach遍历数组

int[] a = {12,12,83,24,5};

for(int e: a){
    // 每次循环从a数组中取出一个元素自动为i变量赋值
    System.out.println( e );
}

演示：forEach遍历集合

List list = new ArrayList();

for(Object obj : list ){
     // 每次循环从list数组中取出一个元素，自动为obj赋值
    System.out.println( obj );
}

演示的代码如下：

package com.txw.test;

import java.util.Arrays;
public class TestMyList {
    public static void main(String[] args) {
        // 数组是一种容器，如何创建、如何存储输入、取出数据、移除数据、遍历
        int[] a = {1,2,3,45};
        // Object[]可以存储任何类型的对象
        Object[] os =new Object[3];		// 0 1 2
        MyList list = new MyList();			// =new Object[3];

        os[0] = "ABC";		// 向输入中添加数据
        list.add( "ABC" );	// os[0] = "ABC"
        list.add( "A" );	// os[1] = "A"
        list.add( "B" );	// os[2] = "B"
        list.add( "C" );	// 扩容 + os[3] = "C"
        // Object obj = os[0];//获取数组中的数据
        Object obj2 = list.get(0); // 获取下标为0的元素  Object obj2 = os[0];
        Object obj3 = list.get(1); // 获取下标为0的元素  Object obj3 = os[1];
        // System.out.println(obj);
       // System.out.println(obj2);
        // 遍历数组
        // for (int i = 0; i < os.length; i++) {
            // System.out.println( os[i] );
        // }
        list.add( "D" );
        list.add( "E" );
        list.add( "F" );
       for(int i=0; i<list.size(); i++) {
            Object obj = list.get(i);
            System.out.println(obj);
       }

    }
}
class MyList{
    Object[] os =new Object[3];
    int index = 0;	// 自定义下标
    public void add(Object obj){		// 向数组中添加元素

        if(index==os.length) 		// 如果容量已满，则扩容
            os = Arrays.copyOf(os,os.length*2);		// 扩容，新数组长度为原数组的两倍
        os[index] = obj;
        index++;

    }
    public Object get(int index){
        return os[index];
    }
    // 返回数组有效元素个数
    public int size(){
        return index;		// 有效元素个数
    }
    // 将元素添加到指定下标位置
    public void add(Object obj,int index){}
    // 移除一个元素
    public void remove(int index){}
}
class Student{}
// class Worker{}
class Animal{}

5 类型安全的集合

类型不安全的集合，任何数据都可以存入该集合中。

List list = new ArrayList();
// 类型不安全
list.add(new Student() );
list.add(new Dog() );
list.add(new Cat() );
list.add(new Worker() );

泛型集合，类型安全的集合。
限定元素的类型，只存储一种类型的元素。
语法如下：
```
List<类名> list = new ArrayList<>();
```
该集合中只能存储与类名相同的对象，否则编译出错。
演示的代码如下：
```
// 只能存储Worker类型的对象
List<Worker> list = new ArrayList<>();
list.add( new Student() );		// Error 
```

使用泛型集合可以更便捷的获取元素。
演示：没有泛型时获取的元素默认都是Object类型。

// 没有泛型
List list = new ArrayList();Object obj = list.get(1);
// forEach遍历
for(Object o: list ){    }

演示：泛型集合获取的元素默认都是泛型类型。

List<Worker> list = new ArrayList<>();// 直接获取指定泛型类型的对象Worker wo = list.get(1);// forEach遍历for(Worker w : list){    }

注意：使用集合泛型是一种编程习惯。

6 习题

完成以下填空： Collection 接口的特点是元素是对象; List 接口的特点是元素有（有|无）顺序，可以（可以|不可以）重复； Set 接口的特点是元素无（有|无）顺序，不可以（可以|不可以）重复； Map 接口的特点是元素是键值对,其中值可以重复，键不可以重复。
(List)关于 List 集合描述正确的是（B C）。
A. 可以利用 List 直接创建集合对象，用于存储多个数据。
B. List 集合可以利用下标操作集合中的元素。
C. Collection 是 List 的父接口。
D. List 中的功能方法全部继承于父接口。
原因：A错误，List是接口不能new对象。
D错误，List接口中的方法除了继承父接口里面的还有自己独有的方法。
(List)欲构造 ArrayList 类的一个实例，此类继承了 List 接口，下列哪个方法是正确的（B）。
A. ArrayList myList = new Object();
B. List myList = new ArrayList();
C. ArrayList myList = new List();
D. List myList = new List();
(List)仔细阅读以下代码，写出程序运行的结果。

package com.txw.test;

import java.util.ArrayList;
import java.util.List;
public class TestList {
    public static void main(String[] args) {
        List<String> list  = new ArrayList<String>();
        list.add("Hello");
        list.add("World");
        list.add("Hello");
        list.add("Learn");
        list.remove("Hello");
        list.remove(0);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

答：输出结果：Hello、Learn
I. 在调用第一个 remove 方法时，会删掉遇到的第一个“Hello”对象， List 中剩下的元素为：World Hello Learn
II. 在调用第二个 remove 方法时，会删掉下标为 0 的元素。List 中剩下的元素为：Hello Learn。
5. (List)简单介绍 ArrayList、LinkedList、Vector 的特性及区别。
答：
ArrayList:底层数组，查询快，增删慢，线程不安全，效率高。
Vector:底层数组，查询快，增删慢，线程安全，效率低。
LinkedList:底层链表，查询慢，增删快，线程不安全，效率高。
6. (List)简述 List list1= new ArrayList()；和 List list2 =new ArrayList()；区别及的作用。
答：
List list1= new ArrayList():只能存储String类型数据。
List list2 =new ArrayList():可以存储Object类型的数据。
作用:创建集合对象时泛型规定了集合中存储的数据类型。
7. (List)编程：创建一个工人类，属性：姓名、年龄、工资，要求如下：
(1) 为 Worker 提供无、有参数的构造方法，属性私有，并提供公开的 get/set。
(2) 创建多个 Worker 类，存储在 List 集合中。
(3) 打印输出所有的工人信息。
(4) 计算所有工人的平均工资。
(5) 打印输出姓名中包含 “胡” 的所有工人信息。
(6) 打印输出所有姓 “胡” 的工人信息。
(7) 键盘输入一个姓名，查找是否存在此员工，存在，则打印输出员工的信息，如果不存在，则输出"查无此人"。
(8) 输入一个工资，查询工资大于输入工资的员工信息。
演示的代码如下：

package com.txw.test;

import java.util.ArrayList;
import java.util.Scanner;
// 工人类
class Worker{
    // 属性私有提供set/get方法
    private String name;        // 姓名
    private int age;            // 年龄
    private double salary;      // 工资

    public Worker(){
        super();
    }

    public Worker(String name, int age, double salary){
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    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 double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Worker{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", salary=" + salary +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        // 创建多个worker对象添加到集合中
        ArrayList<Worker> list = new ArrayList<Worker>();
        list.add(new Worker("胡1", 23, 100000000));
        list.add(new Worker("胡2", 23, 1000000));
        list.add(new Worker("3胡1", 26, 1000000000));
        list.add(new Worker("小明", 20, 10000));
        // 打印所有工人信息
        int age = 0;
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            System.out.println(w);
            age += w.getAge();
        }
        // 员工的平均年龄
        System.out.println("平均年龄: " + age / list.size());
        // 打印所有姓名中带胡的
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            if (w.getName().contains("胡")){
                System.out.println(w);
            }
        }
        System.out.println("--------------------");
        // 打印所有姓胡的员工
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            if (w.getName().charAt(0) == '胡'){
                System.out.println(w);
            }
        }
        System.out.println("-----------");
        // 键盘输入一个姓名，查找是否存在，存在打印该员工信息，不存在打印”查无此人“
        boolean flag = false;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要查询的员工: ");
        String name = sc.next();
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            if (w.getName().equals(name)) {
                flag = true;
                System.out.println(w);
            }
        }
        if (flag == false) {
            System.out.println("查无此人");
        }
        System.out.println("------------");
        // 输入一个工资输出大于输入工资员工的信息 
        double salary = sc.nextDouble();
        for (int i = 0; i < list.size(); i++) {
            Worker w = list.get(i);
            if (w.getSalary() > salary) {
                System.out.println(w);
            }
        }
    }
}

(List)编程：已知有 Worker 类，属性为姓名、年龄、工资，完成类的封装并提供无参数、有参数构造方法，完成以下要求：
(1) 创建一个 List，在 List 中增加三个工人，基本信息如下 :

(2) 在 li4 之前插入一个工人，信息为：姓名：zhao6，年龄：24，工资 3300。
(3) 删除 wang5 的信息。
(4) 利用下标遍历，打印输出所有工人信息。
(5) 利用 forEach 遍历，打印输出所有年龄大于 20 的工人信息。
(6) 对 Worker 类添加 eqauls 方法。
演示的代码如下：

package com.txw.test;

import java.util.ArrayList;
import java.util.Objects;
import java.util.Scanner;
// 工人类
class Worker{
    // 属性私有提供set/get方法
    private String name;        // 姓名
    private int age;            // 年龄
    private double salary;      // 工资

    public Worker(){
        super();
    }

    public Worker(String name, int age, double salary){
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    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 double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Worker worker = (Worker) o;
        return age == worker.age &&
                Double.compare(worker.salary, salary) == 0 &&
                Objects.equals(name, worker.name);
    }

}
public class Test {
    public static void main(String[] args) {
        ArrayList<Worker> list = new ArrayList<Worker>();
        list.add(new Worker("zhang3", 18, 3000));
        list.add(new Worker("li4", 25, 3500));
        list.add(new Worker("wang5", 22, 3200));
        // 在li4之前插入一个工人
        list.add(1, new Worker("zhao6", 23, 3300));
        // 删除wang5的信息
        list.remove(3);
        // 利用下标遍历打印输出所有工人信息
        for(int i = 0; i<list.size(); i++){
            System.out.println(list.get(i));
        }
        System.out.println("------------------");
        // 利用foreach遍历，打印输出所有年龄大于20的工人信息
        for (Worker w : list) {
            if(w.getAge() > 20){
                System.out.println(w);
            }
        }
    }
}

(Set)为上一题的 Worker 类，添加一个 hashCode 方法：public int hashCode(){ // 1 } ,对 1 处代码有以下几种写法：
(1) return 0;
(2) int result = 0; if (name != null) result = name.hashCode(); return result + age;
(3) return super.hashCode(); 现在要把 Worker 对象放入 HashSet 中，希望在 HashSet 中没有重复元素，则下面说法正确的是（B）。
A. 三种写法都正确。
B. (1)、(2)写法正确，(2)的效率更高。
C. (2)写法正确，(1)、(3)写法都不正确。
D. 以上描述都不正确。
原因：覆盖hashcode的原则，尽量保证相同内容返回相同哈希值。
(Set)关于 Set 集合描述正确的是（AC）。
A. 可以利用 Set 创建集合对象，存储多个对象。
B. 可以利用下标操作集合中的数据。
C. Set 集合中所有方法继承于父接口 Collection。
D. 以上描述都不正确。
(List、Set)仔细阅读以下程序，关于程序描述正确的是（ C）。

package com.txw.test;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class TestListSet {
    public static void main(String[] args) {
        List<String> list = new ArrayList<String >();
        list.add("Hello");
        list.add("Learn");
        list.add("Hello");
        list.add("Welcome");
        Set<String> set = new HashSet<String >();
        set.addAll(list);
        System.out.println(set.size());
    }
}

A．编译不通过。
B．编译通过，运行时异常。
C．编译运行都正常，输出 3。
D．编译运行都正常，输出 4。
原因：将list集合中所有元素添加到set集合中，总共有4个元素，因为set集合有去除重复功能，所以会保留下三个元素。
12. (Set)仔细阅读以下代码，将不正确的代地方进行改正。
在这里插入图片描述

答：修改之后的代码如下：

package com.txw.test;

import java.util.HashSet;
import java.util.Set;
public class Test{
    public static void main(String[] args) {
        Set<Worker> set = new HashSet<Worker>();
        set.add(new Worker("tom", 18, 2000));
        set.add(new Worker("tom", 18, 2000));
        // set.add(0,new Worker("jerry", 18, 2000));  没有这个方法
        System.out.println(set.size());
    }
}
class Worker {
    String name;
    int age;
    double salary;

    public Worker() {
        super();
    }

    public Worker(String name, int age, double salary) {
        super();
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    // int hashCode() {
    // return name.hashCode()+age+salary; 
    // }
    // hashCode方法进行覆盖父类中的访问修饰符是public子类只能是public
    // salary是double类型，和int类型相加结果提升为double类型，而返回值是int，需要强转
    public int hashCode(){
        return name.hashCode()+age+(int)salary;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Worker other = (Worker) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (Double.doubleToLongBits(salary) != Double .doubleToLongBits(other.salary))
            return false; return true;
    }
}

(Set)编程：创建一个商品(Product)类,属性：商品名，商品单价，商品的数量，商品产地。
(1) 创建多个商品对象，存储在 Set 集合中，集合中不能出现重复商品，商品名相同即为重复，在 Product 类中添加必要的方法；
(2) 显示所有的商品信息；
(3) 打印输出商品价格 > 1000 的所有商品信息；
(4) 打印售空的商品的信息；
(5) 打印输出商品产地为"北京"的商品信息；
(6) 输入一个商品名，查询出此类商品的信息，如果不存在，则打印商品"商场无此商品！！！"
(7) 输入一个价格段，查询出集合中所有在这个价格区间的所有商品信息。
演示的代码如下：

package com.txw.test;

import java.util.HashSet;
import java.util.Scanner;
// 商品
class Product{
    String brand;       // 商品名
    double price;       // 价格
    int num;            // 商品数量
    String address;     // 产地
    public Product(String brand, double price, int num, String address) {
        super();
        this.brand = brand;
        this.price = price;
        this.num = num;
        this.address = address;
    }

    // 想要保证元素不重复需要覆盖hashcode和equals，商品名称相同就代表一样元素。
    @Override
    public int hashCode() {
        return brand.hashCode();
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Product product = (Product) o;
        return Double.compare(product.price, price) == 0 &&
                num == product.num &&
                brand.equals(product.brand) &&
                address.equals(product.address);
    }

    @Override
    public String toString() {
        return "Product{" +
                "brand='" + brand + '\'' +
                ", price=" + price +
                ", num=" + num +
                ", address='" + address + '\'' +
                '}';
    }
}
public class Test {
    public static void main(String[] args) {
        // 创建多个商品存储在set集合中，集合中不能出现重复商品所以选择hashset集合 
        HashSet<Product> hs = new HashSet<Product>();
        hs.add(new Product("卫龙", 2.5, 100, "北京市沙河"));
        hs.add(new Product("加多宝", 4.0, 20, "北京市海淀区"));
        hs.add(new Product("加多宝", 4.0, 20, "北京市海淀区"));
        hs.add(new Product("龙井", 1500.0, 2, "北京市朝阳区"));
        // 显示所有商品信息 
        for (Product p : hs) {
            System.out.println(p);
        }
        System.out.println("--------------");
        // 输出价格100以上的
        for (Product p : hs) {
            if (p.price > 1000) {
                System.out.println(p);
            }
        }
        System.out.println("---------------");
        // 打印售空的商品信息 
        for (Product p : hs) {
            if (p.num == 0) {
                System.out.println(p);
            }
        }
        System.out.println("---------------");
        // 打印产地北京的商品
        for (Product p : hs) {
            if (p.address.contains("北京")) {
                System.out.println(p);
            }
        }
        System.out.println("------------");
        // 输入一个商品名，查询出此类商品的信息，如果不存在，则打印"商场无此产品" 
        boolean flag = false;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入商品名称:");
        String brand = sc.next();
        for (Product p : hs) {
            if (p.brand.equals(brand)) {
                System.out.println(p);
                flag = true;
            }
        }
        if (!flag) {
            System.out.println("商场无此产品");
        }
        System.out.println("------------");
        // 输入一个价格段，展示所有区间的商品 
        System.out.println("接下来输入按照价格搜索商品");
        System.out.println("请输入最低价格:");
        double start = sc.nextDouble();
        System.out.println("请输入最高价格:");
        double end = sc.nextDouble();
        System.out.println("下面所有商品都满足小主的要求:");
        for (Product p : hs) {
            if (p.price >= start && p.price <= end) {
                System.out.println(p);
            }
        }
    }
}

(Set)编程：随机产生 10 个 0~50 之间的整数，存储在集合中，要求集合中的数据不能重复。知识补充： Random rd= new Random(); //Random 位于 java.util 包中 int n = rd.nextInt(n); //0~n-1 之间的整数。
演示的代码如下：

package com.txw.test;

import java.util.HashSet;
import java.util.Random;
public class Test {
    public static void main(String[] args) {
        //随机生成10个1~50之间的随机数不能重复存储到集合中，选用hashset集合有去重功能
        HashSet<Integer> hs = new HashSet<Integer>();
        Random r = new Random();
        //每次循环创建一个随机数存储到集合中，如果集合中已经存在则不存储，不存在则存储
        // 判断条件如果集合长度小于10就继续存储随机数
        while(hs.size() < 10){
            int random = r.nextInt(51);
            hs.add(random);
        }
        System.out.println(hs);
    }
}

(Set)编程：键盘输入一个字符串，利用集合去除其重复字符，打印输出最终不同的字符。
演示的代码如下：

package com.txw.test;

import java.util.HashSet;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        // 键盘录入一个字符串，利用集合去除里面重复的字符 
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String s = sc.next();
        HashSet<Character> hs = new HashSet<Character>();
        /* 将字符串进行遍历得到每一个字符，将当前字符存储到hashset（只能存储唯一元素）集合中 */
        for(int i = 0; i<s.length(); i++){
            char ch = s.charAt(i);
            hs.add(ch);
        }
        System.out.println(hs);
    }
}

(Map)关于下列 Map 接口中常见的方法：
(1) put 方法表示放入一个键值对，如果键已存在则返回上一次该键对应的值，如果键不存在则返回null;
(2) remove 方法接受1个参数，表示通过键删除这组键值对;
(3) get 方法表示通过键得到这组键值对，get 方法的参数表示传递键，返回值表示该键对应的值;
(4) 要想获得 Map 中所有的键，应该使用方法keySet()该方法返回值类型为set集合;
(5) 要想获得 Map 中所有的值，应该使用方法Values()，该方法返回值类型为Collection。
(Map)关于 HashMap 和 Hashtable 的区别描述正确的是（B）。
A. HashMap 是实现 Map 接口，Hashtable 是实现 Table 接口。
B. HashMap 性能优于 Hashtable，且允许空值和空键。
C. HashMap 是线程安全的。
D. 以上描述都不正确。
(Map)编程：创建一个银行用户 BankUser 类，用户信息为用户 id、用户名 userName、余额 balance;
(1) 利用 HashMap 存储用户信息：id 作为键，用户作为值，创建多个用户对象进行存储。
(2) 遍历打印输出所有银行的用户名和对应的余额。
(3) 键盘输入一个用户名，检测是否存在此用户，存在-打印用户信息；不存在-打印查无此人。
(4) 打印输出余额大于 200000 的用户信息。
演示的代码如下：

package com.txw.test;

import java.util.HashMap;
import java.util.Scanner;
import java.util.Set;
public class Test{
    public static void main(String[] args) {
        // 创建多个用户存储到hashMap集合中 
        HashMap<String, User> hm = new HashMap<String, User>();
        BankUser bu1 = new BankUser("1", "小明", 200000.0);
        BankUser bu2 = new BankUser("2", "小花", 400000.0);
        BankUser bu3 = new BankUser("3", "小刚", 600000.0);
        BankUser bu4 = new BankUser("4", "小红", 800000.0);
        // id作为键,User对象作为值 
        hm.put(bu1.id, bu1.user);
        hm.put(bu2.id, bu2.user);
        hm.put(bu3.id, bu3.user);
        hm.put(bu4.id, bu4.user);
        // 展示所有的name 和对应的余额
        Set<String> keys = hm.keySet();
        for (String key : keys) {
            User user = hm.get(key);
            System.out.println(user.name +" "+user.balance);
        }
        // 键盘录入一个name查看是否存在
        boolean flag = false;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个用户名:");
        String name = sc.next();
        // 遍历集合得到每一个键，根据键获取到值，判断值中的name属性和用户录入的是否一致
        Set<String> keys2 = hm.keySet();
        for (String key : keys2) {
            User value = hm.get(key);
            if(value.name.equals(name)){
                System.out.println(value.name +" "+value.balance); flag = true;
            }
        }
        if(!flag){
            System.out.println("查无此人");
        }
        // 打印余额大于二十万的用户信息 
        // 遍历集合得到每一个键，根据键得到值，获取到每一个值的balance属性，判断如果大于20万则将用户信息就 行打印 
        Set<String> keys3 = hm.keySet();
        for (String key : keys3) {
            User value = hm.get(key);
            if(value.balance > 200000){
                System.out.println(value.name+" "+value.balance);
            }
        }
    }
}
// 银行的用户类 
class BankUser {
    String id;		// 用户id
    User user;// 使用User引用类型数据作为属性，每一个User对象中都有 用户名 和 余额两个内容

    public BankUser(String id, String name, double balance) {
        super(); this.id = id; 
        this.user = new User(name, balance);
    }
}
// 用户模板 
class User {
    String name;	// 用户名 
    double balance;	// 余额 

    public User() {
        super();
    }
    public User(String name, double balance) {
        this.name = name;
        this.balance = balance;
    }
}

(Map)编程：利用 Map，完成下面的功能：从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。如果该年没有举办世界杯，则输出：没有举办世界杯。附录：截止 2009 年，历届世界杯冠军、世界杯冠军以及对应的夺冠年份：

演示的代码如下：

package com.txw.test;

import java.util.*;
public class Test{
    public static void main(String[] args) {
        Map<String, String> worldCupMap = new HashMap<String, String>();
        worldCupMap.put("1930", "乌拉圭");
        worldCupMap.put("1934", "意大利");
        worldCupMap.put("1938", "意大利");
        worldCupMap.put("1950", "乌拉圭");
        worldCupMap.put("1954", "德国");
        worldCupMap.put("1958", "巴西");
        worldCupMap.put("1962", "巴西");
        worldCupMap.put("1966", "英格兰");
        worldCupMap.put("1970", "巴西");
        worldCupMap.put("1974", "德国");
        worldCupMap.put("1978", "阿根廷");
        worldCupMap.put("1982", "意大利");
        worldCupMap.put("1986", "阿根廷");
        worldCupMap.put("1990", "德国");
        worldCupMap.put("1994", "巴西");
        worldCupMap.put("1998", "法国");
        worldCupMap.put("2002", "巴西");
        worldCupMap.put("2006", "意大利");
        /* 从命令行读入一个字符串，表示一个年份，输出该年的世界杯冠军是哪支球队。
        如果该年没有举办世界 杯，则输出：没有举办世界杯 
        */
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份: ");
        String year = sc.next();
        if(worldCupMap.containsKey(year)){
            System.out.println(worldCupMap.get(year));
        }else{
            System.out.println("没有举办");
        }
    }
}

（Map）在上一题目的基础上，增加如下功能：读入一支球队的名字，输出该球队夺冠的年份列表。例如：
(1) 读入“巴西”，应当输出 1958、1962、1970、1994、2002。
(2) 读入“荷兰”，应当输出”没有获得过世界杯”。
演示的代码如下：

package com.txw.test;

import java.util.*;
public class Test{
    public static void main(String[] args) { 
/* 读入一支球队的名字，输出该球队夺冠的年份列表。
 例如： (1) 读入“巴西”，应当输出 1958、1962、1970、1994、2002 
 (2) 读入“荷兰”，应当输出”没有获得过世界杯”。 
 */
        Map<String, String> worldCupMap = new HashMap<String, String>();
        worldCupMap.put("1930", "乌拉圭");
        worldCupMap.put("1934", "意大利");
        worldCupMap.put("1938", "意大利");
        worldCupMap.put("1950", "乌拉圭");
        worldCupMap.put("1954", "德国");
        worldCupMap.put("1958", "巴西");
        worldCupMap.put("1962", "巴西");
        worldCupMap.put("1966", "英格兰");
        worldCupMap.put("1970", "巴西");
        worldCupMap.put("1974", "德国");
        worldCupMap.put("1978", "阿根廷");
        worldCupMap.put("1982", "意大利");
        worldCupMap.put("1986", "阿根廷");
        worldCupMap.put("1990", "德国");
        worldCupMap.put("1994", "巴西");
        worldCupMap.put("1998", "法国");
        worldCupMap.put("2002", "巴西");
        worldCupMap.put("2006", "意大利");
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入国家: ");
        String value = sc.next();
        // 键盘录入一个国家 
        // 判断集合中有没有这个值，没有打印“没有获得过”
        if(worldCupMap.containsValue(value)){
            // 集合中有这个国家，则遍历集合，得到每一个键，通过键获取值，判断每一个值是否和用户录入的一致， 如果一致。
            // 打印该国家对应的键 
            Set<String> keys = worldCupMap.keySet();
            for (String key : keys) {
                String value2 = worldCupMap.get(key);
                if(value.equals(value2)){
                    System.out.println(key);
                }
            }
        }else{
            System.out.println("没有获得过");
        }
    }
}

(Map)编程：已知某学校的教学课程内容安排如下：

完成下列要求：
(1) 使用 Map，以老师的名字作为键，教授的课程名作为值，表示上述课程安排。
(2) 增加了一位新老师 Allen 教 JDBC。
(3) Lucy 改为教 CoreJava。
(4) 遍历 Map，输出所有的老师及老师教授的课程。
(5) 利用 Map，输出所有教 JSP 的老师。
(6) 统计教授 CoreJava 和 JDBC 老师的人数。
演示的代码如下：

package com.txw.test;

import java.util.*;
public class Test {
    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("Tom", "CoreJava");
        map.put("John", "Oracle");
        map.put("Susan", "Oracle");
        map.put("Jerry", "JDBC");
        map.put("Jim", "Unix");
        map.put("Kevin", "JSP");
        map.put("Lucy", "JSP");
        // 2) 增加了一个Allen教JDBC 
        map.put("Allen", "JDBC");
        // 3) Lucy改教CoreJava
        map.put("Lucy", "CoreJava");
        // 遍历Map 
        Set<String> set = map.keySet();
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String key = it.next();
            String value = map.get(key);
            System.out.println(key + " --> " + value);
        }
        // 输出所有教JSP的老师
        it = set.iterator();
        while(it.hasNext()){
            String key = it.next();
            String value = map.get(key);
            if (value.equals("JSP")){
                System.out.println(key);
            }
        }
        // 统计Corejava和JDBC老师人数
        int CorejavaCount = 0;
        int JDBCCount = 0;
        Set<String> keys = map.keySet();
        for (String key : keys) {
            String value = map.get(key);
            if(value.equals("CoreJava")){
                CorejavaCount++;
            }
            if(value.equals("JDBC")){
                JDBCCount++;
            }
        }
        System.out.println(CorejavaCount);
        System.out.println(JDBCCount);
    }
}

(Map) 给定一个字符串,请输出该字符串由哪些字符组成,每个字符出现几次?
演示的代码如下：

package com.txw.test;

import java.util.*;
public class Test{
    public static void main(String[] args) {
        // 给定一个字符串,请输出该字符串由哪些字符组成,每个字符出现几次? 
        String str = "aaaaaaabbbbbcerrrrggggggggsssssspoqqqqq";
        HashMap<Character,Integer> map = new HashMap<Character,Integer>();
        // 使用hashMap集合，键作为字符串中的每一个字符，值作为这个字符所出现的次数
        // 遍历字符串，得到每一个字符，判断集合中是否有改建，如果没有调用put方法值设置为1，表示第一次出现该 字符 
        // 如果集合中有这个键，则获取上一次的值进行+1，重新赋值 
        for(int i = 0 ; i < str.length() ; i++){
            char c = str.charAt(i);
            if (map.containsKey(c)){
                int m = map.get(c);
                map.put(c, m+1);
            }else{
                map.put(c, 1);
            }
        }
        Set<Character> keys = map.keySet();
        for(char c : keys){
            int i = map.get(c);
            System.out.println(c+" ---- "+i);
        }
    }
}

总结

在这里插入图片描述

学无止路

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
0
评论
集合的细节

集合概念：将多个对象集中整合在一个对象中，用来存储对象的容器，与数组的作用一样，但更加便捷。位置：Java.util包中。1 Collection 接口作用：存储对象。常用方法：方法名作用add(Object obj)添加一个对象remove(Object obj)删除一个对象size()返回有效元素个数contains(Object o)判断集合中是否有与o相同的元素clear()清空集合isEmpty()判断是否为空集合
复制链接

扫一扫