Java集合

最新推荐文章于 2023-09-22 15:35:15 发布
最新推荐文章于 2023-09-22 15:35:15 发布
阅读量298 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言 前端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43446733/article/details/124813852
版权

在这里插入图片描述

1、集合基础

1.1、集合概述

集合类的特点：提供一种存储空间可变的存储模型，存储数据容量可以发送改变
集合类有很多，ArrayList
ArrayList<E>:
	1.可调整大小的数组实现
	2.<E>是一种特殊的数据类型，泛型
怎么用：
	1. 在出现E的地方使用引用数据类型替换即可
	2. 举例：ArrayList<String>,ArrayList<Stduent>

2、ArrayList

1.1、ArrayList构造方法和添加方法

方法名说明
public ArrayList()创建一个空的集合对象
public boolean add(E a)将指定的元素添加到此集合的末尾
public void add(int index,E element)在此集合的指定位置添加指定的元素
import java.util.ArrayList;

public class TextArrayList {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();//创建一个集合
        System.out.println("list:" + list);//输出空列表list:[]
        System.out.println(list.add("hello"));//输出添加成功与否
        System.out.println("list:" + list);//输出list:[hello]
        list.add("world");
        list.add("java");
        System.out.println(list);//[hello, world, java]
        list.add(2,"javaSE");//在指定位置添加元素
        System.out.println(list);//[hello, world, javaSE, java]
        //当前集合里只有4个数据,现在往第6个位置添加数据
        //会报错触发运行时异常
        // IndexOutOfBoundsException: Index: 5, Size: 4
        list.add(5,"javaSE");
        System.out.println(list);

    }
}

1.2、ArrayList集合常用方法

方法名说明
public boolean remove(Objecto)删除指定的元素，返回删除是否成功
public E remove(int index)删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)修改指定索引处的元素，返回被修改的元素
public E get(int index)返回指定索引处的元素
public int size0返回集合中的元素的个数
//集合的增删改查
import java.util.ArrayList;

public class TextArrayList2 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();//创建一个集合
        list.add("hello");
        list.add("world");
        list.add("java");
        System.out.println(list);//[hello, world, java]
//        System.out.println(list.remove("world"));//删除指定的元素
//        System.out.println(list);//删除完成[hello, java]

//        System.out.println(list.remove(2));//删除指定索引的元素,并返回被删除的元素：java
//        System.out.println(list);//[hello, world]

//        System.out.println(list.set(1,"世界"));//修改指定索引的元素，并返回被修改的元素：world
//        System.out.println(list);//[hello, 世界, java]

        System.out.println(list.get(1));//获取索引为1的元素，不会改变集合里的元素
        System.out.println(list.size());//获取集合长度
        
        for (String s : list) {//遍历集合
            System.out.println(s);
        }
    }
}

集合的遍历

//集合的遍历
public class TextArrayList3 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();//创建一个集合
        list.add("hello");
        list.add("world");
        list.add("java");

        for (String s : list) {//遍历集合
            System.out.println(s);
        }

        ArrayList<Person> people = new ArrayList<>();//创建集合
        people.add(new Person("张三",20));//向集合添加元素
        people.add(new Person("李四",30));
        people.add(new Person("王五",25));

        System.out.println("-----------普通for循环遍历--------------");
        for (int i = 0; i < people.size(); i++) {//普通for循环遍历
            System.out.println(people.get(i));
        }
        System.out.println("-----------增强型for循环遍历--------------");
        for (Person persons : people) {//增强型for循环
            System.out.println(persons);
        }
    }
}
class Person{
    /**
     * 这一个类的标准配置
     * 无参构造是必须的,有参构造是选配
     * get,set方法
     * toString选配
     */

    private String name;
    private int age;

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

    public Person() {
    }

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

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

从键盘输入数据保存到集合

import java.util.ArrayList;
import java.util.Scanner;

//集合的遍历
public class TextArrayList4 {
    public static void main(String[] args) {

        ArrayList<Person> people = new ArrayList<>();//创建集合
        Scanner scanner = new Scanner(System.in);

        for (int i = 0; i < 3; i++) {
            Person person = new Person();//创建个人的对象
            System.out.print("输入人员姓名:");
            person.setName(scanner.next());//从键盘获取姓名
            System.out.print("输入人员年龄:");
            person.setAge(scanner.nextInt());//获取年龄
            people.add(person);//添加进集合
        }

        System.out.println("-----------增强型for循环遍历--------------");
        for (Person persons : people) {//增强型for循环
            System.out.println(persons);//这里会默认调用Person对象的toString()方法
        }
        scanner.close();//关闭输入输出接口释放资源
    }
}

3、Collection集合

3.1、 Collection集合创建

Collection是一个接口，所以只能new一个他的子类来实现创建

Collection<String> collection = new ArrayList<>();
//使用方法跟ArrayList类一样

3.2、Collextion 集合的遍历

Iterator：迭代器，集合的专用遍历方式
	1. Iterator<E> iterator();返回此集合的迭代器，通过集合的iterator()方法得到
	2. 迭代器是通过集合的iterator()方法得到的，所以我们说他是依赖于集合而存在的

Iterator中的常用方法
	1. E next(): 返回迭代中的下一个元素
	2. boolean hasNex():如果迭代具有更多元素，则返回true

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

//用迭代器遍历集合中的元素
public class TestCollection {
    public static void main(String[] args) {
        Collection<String> collection = new ArrayList<>();
        collection.add("hello");
        collection.add("world");
        collection.add("java");
        Iterator<String> iterator = collection.iterator();
        //迭代器是一次性的,用完就报废
        while (iterator.hasNext()){//判断集合是否还有元素
            System.out.println(iterator.next());//获取元素
        }
        //迭代器访问越界的元素会抛出异常
        //这个迭代器已经走到头了,再调用一次就会越界
        //System.out.println(iterator.next());//NoSuchElementException
    }
}

4、List 集合

List结合概述
	1. 有序集合(也称为序列)。该界面的用户可以精确控制列表中每个元素的插入位置。用户可以通过整数索引 (列表中的位置)访问元素，并搜索列表中的元素。
	2. 与Set集合不同，列表通常允许重复的元素
List集合的特点
	1. 有序：存储和取出的元素顺序一致
	2. 可重复：存储的元素可以重复

List<String> list =new ArrayList<>();
//使用方法跟ArrayList类一样

4.1、List集合的特有方法

方法名说明
void add(int index,E element)在此集合中的指定位置插入指定的元素
E remove(int index)删除指定索引处的元素，返回被删除的元素
E set(int index,E element)修改指定索引处的元素，返回被修改的元素
E get(int index)返回指定索弓

4.2、并发修改异常

黑马程序员全套Java教程

4.3、Listlterator

用于允许程序员沿任一-方向遍历列表的列表的迭代器， 在迭代期间修改列表，并获取列表中迭代器的当前位置。AListIterator没有电流元素; 它的光标位置总是位于通过调用previous ()返回的元素和通过调用next ()返回的元素next()。长度为的列表的迭代器具有n+1可能的光标位置

Listlterator:列表迭代器
	1. 通过List集合的listlterator0方法得到， 所以说它是List集合特有的迭代器
	2. 用于允许程序员沿任一方向遍历列表的列表迭代器， 在迭代期间修改列表，并获取列表中迭代器的当前位置
	
Listlterator中的常用方法
	1. E next0: 返回迭代中的下一个元素
	2. boolean hasNext():如果迭代具有更多元素,则返回true
	3. E previous0:返回列表中的上一个元素boolean hasPrevious(: 如果此列表迭代器在相反方向遍历列表时具有更多元素,则返回true
	4. void add(E e):将指定的元素插入列表

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

public class TestListIterator {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();//创建有序列表
        list.add("hello");
        list.add("world");
        list.add("java");

        ListIterator<String> listIterator = list.listIterator();//生成迭代器
        System.out.println("------------------正序遍历-----------");
        while (listIterator.hasNext()){//正序遍历
            System.out.println(listIterator.nextIndex());//返回当前元素在列表中的位置
            System.out.println(listIterator.next());
        }
        System.out.println("------------------倒序遍历-----------");
        while (listIterator.hasPrevious()){//倒序遍历
            System.out.println(listIterator.previousIndex());//返回当前元素在列表中的位置
            System.out.println(listIterator.previous());

        }
        System.out.println("------------------添加元素-----------");
        while (listIterator.hasNext()){//正序遍历
            String next = listIterator.next();
            System.out.println(next);
            //listIterator迭代器不会触发并发修改异常,但需要用该迭代器添加元素
            if (next.equals("world")){
                System.out.println("添加元素 ");
                listIterator.add("javaee");//添加之后不会再本次遍历中打印出来
            }
        }
        for (String s : list) {//再遍历一遍就可以打印出来"javaee"
            System.out.println(s);
        }
    }
}

4.4、List队列

	数据结构是计算机存储、组织数据的方式。是指相互之间存在一种或多种特定关 系的数据元素的集合
通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率

4.4.1、常见的数据结构之栈

数据进入栈模型的过程称为:压/进栈
数据离开栈模型的过程称为:弹/出栈
栈是一种数据先进后出的模型

在这里插入图片描述

4.4.2、常见的数据结构之队列

数据从后端进入队列模型的过程称为：入队列
数据从前端离开队列模型的过程称为：出队列
队列是一种数据先进先出的模型

在这里插入图片描述

4.4.3、常见的数据结构之数组

数组是一种查询快，增删慢的模型
查询数据通过索引定位，查询任意数据耗时相同，查询效率高
删除数据时，要将原始数据删除，同时后面每个数据前移，删除效率低
添加数据时，添加位置后的每个数据后移，再添加元素，添加效率极低

4.4.4、常见的数据结构之链表

链表是-种增删快的模型(对比数组)
链表是一种查询慢的模型(对比数组)
查询数据D是否存在，必须从头(head)开始查询
查询第3个数据，必须从头(head)开始查询

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

4.4.5、常见的数据结构之哈希表

黑马程序员全套Java教程

4.4.6、 List集合子类特点

List集合常用子类: ArrayList, LinkedList

  1. ArrayList: 底层数据结构是数组，查询快，增删慢
  2. LinkedList:底层数据结构是链表，查询慢,增删快

5、LinkedList集合

5.1、LinkedList集合的特有功能

方法名说明
public void addFirst(E e)在该列表开头插入指定的元素
public void addLast(E e)将指定的元素追加到此列表的末尾
public E getFirst(）返回此列表中的第一个元素
public E getLast(）返回此列表中的最后一个元素
public E removeFirst(）从此列表中删除并返回第一个元素
public E removeLast(）从此列表中删除并返回最后一个元素
import java.util.LinkedList;

public class TestLinkedList {
    public static void main(String[] args) {
        LinkedList<String> linkedList = new LinkedList<>();
        linkedList.add("hello");
        linkedList.add("world");
        linkedList.add("java");

        System.out.println(linkedList);
        System.out.println("-----------添加-------------------");
        linkedList.addFirst("你好");//添加到列表的开头
        linkedList.addLast("世界");//添加到列表的结尾
        System.out.println(linkedList);
        System.out.println("-----------查询-------------------");
        System.out.println(linkedList.getFirst());//返回列表的第一个元素
        System.out.println(linkedList.getLast());//返回列表的最后一个元素
        System.out.println("-----------删除-------------------");
        System.out.println(linkedList.removeFirst());//删除列表的第一个元素并返回
        System.out.println(linkedList.removeLast());//删除列表的最后一个元素并返回
        System.out.println(linkedList);
    }
}

6、Set 集合

6.1、Set集合概述和特点

Set集合特点
	1. 不包含重复元素的集合
	2. 没有带索引的方法，所以不能使用普通for循环遍历

import java.util.HashSet;

public class TestSet {
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<>();//HashSet对集合的顺序无法保证，写进去的和读出来的顺序不一样
        set.add("hello");
        set.add("world");
        set.add("java");

        for (String s : set) {//遍历的元素是随机的，也不算随机根据放入的内容变化
            System.out.println(s);
        }
        System.out.println("-----------添加之后-------------------");
        System.out.println(set.add("hello"));//set集合不包含重复元素，所以它会被丢掉;返回false
        for (String s : set) {//遍历的元素是随机的，也不算随机根据放入的内容变化
            System.out.println(s);
        }
    }
}

6.2、哈希值

哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
	public int hashCode0:返回对象的哈希码值
对象的哈希值特点
1. 同一个对象多次调用hashCode(方法返回的哈希值是相同的
2. 默认情况下，不同对象的哈希值是不同的。而重写hashCode(方法,可以实现让不同对象的哈希值相同

6.3、Hash Set集合概述和特点

HashSet集合特点
1. 底层数据结构是哈希表
2. 对集合的迭代顺序不作任何保证，也就是说不保证存储和取出的元素顺序一致
3. 没有带索引 |的方法,所以不能使用普通for循环遍历
4. 由于是Set集合，所以是不包含重复元素的集合

在这里插入图片描述

6.4、L inkedHashSet

L inkedHashSet集合特点
	1:哈希表和链表实现的Set接口，具有可预测的迭代次序
	2:由链表保证元素有序，也就是说元素的存储和取出顺序是一致的
	3:由哈希表保证元素唯一，也就是说没有重复的元素

6.5、 TreeSet集合概述和特点

TreeSet集合特点
1. 元素有序， 这里的顺序不是指存储和取出的顺序，而是按照-定的规则进行排序，具体排序方式取决于构造方法
	TreeSet0:根据其元素的自然排序进行排序
	TreeSet(Comparator comparator):根据指定的比较器进行排序
2. 没有带索引的方法， 所以不能使用普通for循环遍历
3. 由于是Set集合， 所以不包含重复元素的集合

import java.util.TreeSet;

public class TestTreeSet {
    public static void main(String[] args) {
        TreeSet<Integer> treeSet = new TreeSet<>();//默认自然排序，数据类型必须选择基本类型的包装类
        treeSet.add(50);
        treeSet.add(10);
        treeSet.add(40);
        treeSet.add(20);
        treeSet.add(30);
        treeSet.add(30);//因为实现了Set接口所以它里面的元素是不可以重复的
        
        for (Integer integer : treeSet) {
            System.out.println(integer);
        }
    }
}

6.7、自然排序Comparable的使用

  1. 存储学生对象并遍历, 创建TreeSet集合使用无参构造方法
  2. 要求:按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
    结论
  3. 用TreeSet集合存储自定义对象， 无参构造方法使用的是自然排序对元素进行排序的
  4. 自然排序, 就是让元素所属的类实现Comparable接口， 重写compareTo(T o)方法
  5. 重写方法时，一 定要注意排序规则必须按照要求的主要条件和次要条件来写
import java.util.TreeSet;

public class TestComparable {
    public static void main(String[] args) {
        TreeSet<Student> treeSet = new TreeSet<>();
        treeSet.add(new Student("zhangSan",10));
        treeSet.add(new Student("liSi",15));
        treeSet.add(new Student("wangWu",14));
        treeSet.add(new Student("laoLiu",12));

        for (Student student : treeSet) {
            System.out.println(student.name+","+student.age);
            /*
            zhangSan,10
            laoLiu,12
            wangWu,14
            liSi,15
             */
        }
        System.out.println("----------添加后---------------");
        treeSet.add(new Student("wangWu",14));//重复的元素不会添加到集合中
        treeSet.add(new Student("bieQi",12));//年龄相同会按照字母排序
        for (Student student : treeSet) {
            System.out.println(student.name+","+student.age);
            /*
            zhangSan,10
            bieQi,12
            laoLiu,12
            wangWu,14
            liSi,15
             */
        }
    }
}
class Student   implements Comparable<Student> {//实现Comparable接口
    String name;
    int age;

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

    public Student() {
    }

    @Override
    public int compareTo(Student o) {//实现compareTo比较方法
//        return 0;//代表重复
//        return 1;//正数升序
//        return -1;//负数降序
        int num = this.age-o.age;
        return num==0?this.name.compareTo(o.name):num;
    }
}

6.8、比较器排序Comparator的使用

  1. 存储学生对象并遍历， 创建TreeSet集 合使用带参构造方法
  2. 要求: 按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序
//main方法里面的代码
TreeSet<Student> treeSet = new TreeSet<>(new Comparator<Student>() {//带参构造方法
    @Override
    public int compare(Student o1, Student o2) {
        int num = o1.age-o2.age;
        return num==0?o1.name.compareTo(o2.name):num;
    }
});

treeSet.add(new Student("zhangSan",10));
treeSet.add(new Student("liSi",15));
treeSet.add(new Student("wangWu",14));
treeSet.add(new Student("laoLiu",12));

for (Student student : treeSet) {
    System.out.println(student.name+","+student.age);
    /*
    zhangSan,10
    laoLiu,12
    wangWu,14
    liSi,15
     */
}
System.out.println("----------添加后---------------");
treeSet.add(new Student("wangWu",14));//重复的元素不会添加到集合中
treeSet.add(new Student("bieQi",12));//年龄相同会按照字母排序
for (Student student : treeSet) {
    System.out.println(student.name+","+student.age);
    /*
    zhangSan,10
    bieQi,12
    laoLiu,12
    wangWu,14
    liSi,15
     */
}

6.9、生成10个1~20，不重复的随机数

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

/*
生成10个1~20，不重复的随机数
 */
public class SetDemo01 {
    public static void main(String[] args) {
        //Set<Integer> set = new HashSet<>();//利用Set集合的不可重复性
        Set<Integer> set = new TreeSet<>();//TreeSet对象可以排序

        Random random = new Random();

        while (set.size()<10){
            set.add(random.nextInt(20)+1);
        }
        for (Integer integer : set) {
            System.out.println(integer);
        }
    }
}

7、泛型

7.1、泛型概述

  1. 泛型:是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编泽时检测到非法的类型它的本质是参数化类型，也就是说所操作的数据类型被指定为个参数
    一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参，那么参数化类型怎么理解呢?
    顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型
    这种参数类型可以用在类，方法和按口中,分别被称为泛型类，泛型方法，泛型接口
  2. 泛型定义格式:
    1. <类型>: 指定-一种类型的格式。这里的类型可以看成是形参
    2. <类型1,类型…>: 指定多种类型的格式，多种类型之间用逗号隔开，这里的类型可以看成是形参
    3. 将来具体调用时候给定的类型可以看成是实参， 并且实参的类型只能是引用数据类型
  3. 泛型的好处：
    1. 把运行时期的问题提前到编译时期
    2. 避免强制类型转换

7.2、泛型类

public class TestGenerosityClass {
    public static void main(String[] args) {
        //泛型可以让输入的参数任意化，大大提高程序的适应性
        Test<String> stringTest = new Test<>();//定义成字符串类型
        stringTest.setArbitrarily("字符串");
        System.out.println(stringTest.getArbitrarily());

        Test<Integer> integerTest = new Test<>();//定义成Integer类型
        integerTest.setArbitrarily(10);
        System.out.println(integerTest.getArbitrarily());

        Test<Test> testTest = new Test<>();//定义成他自己的类型
        testTest.setArbitrarily(new Test<String>());
        testTest.getArbitrarily().setArbitrarily("他自己");
        System.out.println(testTest.getArbitrarily().getArbitrarily());
    }
}
//定义泛型类
class Test<E>{
    E arbitrarily;

    public E getArbitrarily() {
        return arbitrarily;
    }

    public void setArbitrarily(E arbitrarily) {
        this.arbitrarily = arbitrarily;
    }
}

7.3、泛型方法

public class TestGenerosityMethod {
    public static void main(String[] args) {
        TestMethod testMethod = new TestMethod();
        testMethod.swh("字符串");//泛型方法,可以自适应参数
        testMethod.swh(11);
        testMethod.swh(true);
        testMethod.swh(11.0592);
    }
}
//定义泛型方法
class TestMethod{
    public <E> void swh(E e) {//泛型方法的定义
        System.out.println(e);
    }

}

7.4、泛型接口

泛型接口的定义格式:

  • 格式: 修饰符interface接口名<类型>1 )
  • 范例: public interface Generic{ )

7.5、类型通配符

为了表示各种泛型List的父类，可以使用类型通符

  • 类型通配符: <?>
  • List<?>: 表示元素类型未知的List,它的元素可以匹配任何的类型
  • 这种带通配符的L ist仅表示它是各种泛型Lst的父类，并不能把元素添加到其中

如果说我们不希望List<?>是任何泛型List的父类,只希望它代表某一类泛型List的父类, 可以使用类型通配符的上限

  • 类型通配符 上限: <? extends类型>
  • List<? extends Number>:它表示的类型是Number或者其子类型
    除了可以指定类型通配符的.上限，我们也可以指定类型通配符的下限
  • 类型通配符 下限: <?super 类型>
  • List<? super Number>:它表示的类型是Number或者其父类型
import java.util.ArrayList;
import java.util.List;

public class GenericDemo {
    public static void main(String[] args) {
        //<?>类型通配符
        List<?> list1 = new ArrayList<String>();
        List<?> list2 = new ArrayList<Object>();
        List<?> list3 = new ArrayList<Number>();

        //类型通配符上限 <? extends 类型>
        List<? extends Number> list4 = new ArrayList<Number>();
        //List<? extends Number> list5 = new ArrayList<Object>();
        List<? extends Number> list6 = new ArrayList<Integer>();

        //类型通配符下限 <? super 类型>
        List<? super Number> list7 = new ArrayList<Number>();
        List<? super Number> list8 = new ArrayList<Object>();
        //List<? super Number> list9 = new ArrayList<Integer>();
        

    }
}

8、 Map

8.1、 Map集合概述和使用

Map集合概述

  • Interface Map<K,V>
  • K:键的类型; V:值的类型

将键映射到值的对象;不能包含重复的键;每个键可以映射到最多一个值
举例:

学生的学号和姓名
itheima001	林青霞
itheima002	张曼玉
itheima003	王祖贤

创建Map集合的对象

  • 多态的方式
  • 具体的实现类HashMap
import java.util.HashMap;
import java.util.Map;

public class TestMap {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        //V put(K key,V value) 将指定的值与该映射中的指定的键相关联
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        System.out.println(map);
        System.out.println("---------修改后1------------");
        map.put("itheima003","张三丰");//一个集合中的键是不能重复的,如果添加一样的键会修改原来的值
        System.out.println(map);
        System.out.println("---------修改后2------------");
        map.put("itheima004","张曼玉");//它允许有多个一样的值,但只有一个一样的键
        System.out.println(map);
    }
}

8.2、 Map集合的基本功能

方法名说明
V put(K key,V value)添加元素
V remove(Object key)根据键删除键值对元素
void clear()移除所有的键值对元素
boolean containsKey(Object key)判断集合是否包含指定的键
boolean containsValue(Object value)判断集合是否包含指定的值
boolean isEmpty()判断集合是否为空
int size()集合的长度，也就是集合中键值对的个数
import java.util.HashMap;
import java.util.Map;

public class TestMap2 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        //V put(K key,V value) 将指定的值与该映射中的指定的键相关联
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");

        System.out.println(map.remove("itheima003"));//根据键,删除键值对,并返回值
        System.out.println(map);

//        map.clear();//删除集合中的所有元素
//        System.out.println(map);//
        //判断集合中是否有这个键
        System.out.println(map.containsKey("itheima002"));//true
        System.out.println(map.containsKey("itheima004"));//false

        //判断集合中是否有这个值
        System.out.println(map.containsValue("张曼玉"));//true
        System.out.println(map.containsValue("itheima004"));//false
    }
}

8.3、 Map集合的获取功能

方法名说明
V get(Object key)根据健获取值
Set keySet()获取所有键的集合
Collection value()获取所有值的集合
Set<Map.Entry<K,V> > entrySet()获取所有键值对对象的集合
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class TestMap3 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        //V put(K key,V value) 将指定的值与该映射中的指定的键相关联
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        map.put("itheima004","王祖贤");

        System.out.println(map.get("itheima001"));//根据键返回值

        Set<String> keySet = map.keySet();//返回集合中所有的键
        System.out.println(keySet);

        Collection<String> values = map.values();//返回集合中的所有的值
        System.out.println(values);
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            System.out.println(entry.getKey());
        }

        System.out.println(entries);

    }
}

案例1: HashMap集合存储学生对象并遍历

需求:创建一个HashMap集合，键是学生对象 (Student, 值是居住地(String).存储多个健值对元素，井遍历。
要求保证健的唯一性:如果学生对象的成员安量值相同，我们就认为是同一个对象
思路:
①定义学生类
②创建HashMap集合对象
③创建学生对象
④把学生添加到集合
⑤遍历集合
⑥在学生类中重写两个方法
hashCode()
equals()

import java.util.HashMap;
import java.util.Map;

public class TestMap4 {
    public static void main(String[] args) {
        Map<Student,String> map = new HashMap<>();
        //V put(K key,V value) 将指定的值与该映射中的指定的键相关联
        Student s1 = new Student("林青霞", 13);
        Student s2 = new Student("张曼玉", 13);
        Student s3 = new Student("王祖贤", 13);
        map.put(s1,"北京");
        map.put(s2,"上海");
        map.put(s3,"南京");

        for (Student student : map.keySet()) {//获取map集合的键
            System.out.println(student.getName()+","+student.getAge()+","+map.get(student));
        }


    }
}
class Student{
    private String name;
    private int age;

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

    public Student() {
    }

    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;
    }
    //重写equals和hashCode来保证键的唯一性
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name.equals(student.name);
    }

    @Override
    public int hashCode() {
        int result = name.hashCode();
        result = 31 * result + age;
        return result;
    }
}

案例2:键盘录入-个字符串,要求统计字符串中每个字符串出现的次数。

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

/*
需求:键盘录入-个字符串,要求统计字符串中每个字符串出现的次数。
举例:键盘录入"aababcabcdabcde"
在控制台输出: "a()b(4)C(3)d(2)e(1)"
思路:
①键盘录入-个字符串
②创建HashMap集合，健是Character, 值是Integer
③遍历字符串,得到每一个字符
④拿得到的每一个字符作为键到HashMap集合中去找对应的值，看其返回值
如果返回值是null:说明该字符在HashMap集合中不存在，就把该字符作为健，1作为值存储
如果返回值不是null:说明该字符在HashMap集合中存在，把该值加1 ,然后重新存储该字符和对应的值
⑤遍历HashMap集合，得到健和值，按照要求进行拼接
⑥输出结果

 */
public class TestMap5 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        HashMap<Character, Integer> hashMap = new HashMap<>();

        System.out.println("输入字符串:");
        String nextLine = scanner.nextLine();

        for (int i = 0; i < nextLine.length(); i++) {
            char c = nextLine.charAt(i);
            if(hashMap.get(c)==null){//如果没有这个键,就添加这个键
                hashMap.put(c,1);
            }else {//如果有这个键,就把值加1覆盖掉原来的值
                hashMap.put(c,hashMap.get(c)+1);
            }
        }
        Set<Character> keySet = hashMap.keySet();//生成键的集合
        StringBuilder builder = new StringBuilder();//用StringBuilder类提升字符串拼接效率
        for (Character character : keySet) {
            builder.append(character).append(("(")).append(hashMap.get(character)).append(")");
        }
        String s = builder.toString();//将StringBuilder转为String类型
        System.out.println(s);
        
        scanner.close();
    }
}

9、 Collections

9.1、 Collections概述和使用

Collections类的概述

 是针对集合操作的工具类

Collections类的常用方法

public static <T extends Comparable<? super T>> void sort(List<T> list):将指定的列表按升序排序
public static void reverse(List<?> list):反转指定列表中元素的顺序
public static void shuffle(List<?> list): 使用默认的随机源随机排列指定的列表

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/*
public static <T extends Comparable<? super T>> void sort(List<T> list):将指定的列表按升序排序
public static void reverse(List<?> list):反转指定列表中元素的顺序
public static void shuffle(List<?> list): 使用默认的随机源随机排列指定的列表
 */
public class TestCollections {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(20);
        list.add(10);
        list.add(50);
        list.add(40);
        list.add(30);

        System.out.println(list);

        Collections.sort(list);//将指定的列表按升序排序
        System.out.println(list);

        Collections.reverse(list);//反转指定列表中元素的顺序
        System.out.println(list);

        Collections.shuffle(list);//使用默认的随机源随机排列指定的列表
        System.out.println(list);
    }
}
qq_43446733
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java 集合
weixin_44804144的博客
03-25 209
常见数据结构 1)数据结构：计算机对数据存储的一种安排 2)常见数据结构 ①数组； ②基于数组模拟的容器类； ③基于链表结构的容器类； 基于数组和基于变量的链表结构，对于数据操作 增删改查 效率问题 1)添加： 数组复制创建新数组， 链表直接挂在尾端 ：基于数组慢，变量链表快 2)删除： 数组需要复制数据 链表直接改变链接 ： 基于数组慢，变量链表快 3)修改： 数组直接找到索引位置...
List异常报错：list All elements are null
weixin_52365457的博客
09-14 4875
List异常报错： list All elements are null 欢迎并感谢浏览卢小龙的本篇文章问题描述问题排查问题解决 欢迎并感谢浏览卢小龙的本篇文章 你好！亲爱的读者，本篇文章将主要记录本人对List集合数据处理时元素为空的踩坑问题记录，方便自己的学习历程记录以及复习参考，若有言错之处，请各位给予指点. 问题描述 笔者当时正对List进行遍历处理，发现有一List集合并未被**Collectionutils.isEmpty()**判断出来，在确定不是Util的问题后，在Debug的过程中发现：
List集合异常：list All elements are null
热门推荐
qq_36458574的博客
04-14 2万+
ArrayList允许添加null值。所以导致查询一个字段的时候会出现集合大小不为0，但是里面的元素却是All elements are null。 1.场景： 先看下迷惑现场： 会发现集合strings大小为1，但是集合里面却没有确切数据，显示为All elements are null 。初次发现堪称神奇啊。 然后看下这个集合的SQL： 返回的是一个字段 contract_no 并且显示的是Null。 然后再看下如果查询这张表的所有字段： 会惊奇的发现有一条数据，并且这条数据的contract_n
List异常报错：All elements are null
最新发布
添腹一饼
09-22 5671
用mybatis查询出来的集合为空，无数据。但是用CollectionUtils.isEmpty()判断为空一直是false，也就是一直不为空。通过Debug发现该集合确实size不等于0，但是提示信息为"所有元素都为空"，显示为"All elements are null"。通过在Navicat中执行sql发现查出来的数据都显示为null。null并不是没有数据，而是所有数据都为null。忽略了ArrayList允许添加null值！判断集合list是否为空的条件，数据库中没有数据的结果如下。
Java集合使用注意事项
大河之犬的博客
01-28 681
方法的时间复杂度也是 O(1)，不过，也有很多复杂度不是 O(1) 的，比如。的一个内部类,这个内部类并没有实现集合的修改方法或者说并没有重写这些方法。的真正得到的参数就不是数组中的元素，而是数组对象本身！元素唯一的特性，可以快速对一个集合进行去重操作，避免使用。把数组转换成集合时，不能使用其修改集合相关的方法， 它的。的唯一元素就是这个数组，这也就解释了上面的代码。，传入的是类型完全一致、长度为 0 的空数组。操作直接调用的是集合自己的方法，而不是。使用集合转数组的方法，必须使用集合的。
list 集合里面All elements are null 但是长度为1
m0_55584658的博客
06-07 1011
All elements are null
java 集合
04-07
本文将深入探讨Java集合框架的基础知识，包括接口、类、以及它们在实际开发中的应用。 首先，Java集合框架由一系列接口和实现这些接口的类组成。主要的接口有`List`、`Set`和`Queue`，它们各自代表了不同特性的数据...
Java集合概述与实例分析
10-26
Java集合框架是Java编程语言中的一个核心特性，它提供了一种高效、灵活的方式来存储和操作对象数组。在Java中，集合被分为两个主要接口：Collection和Map。本篇将深入探讨Collection接口及其子接口，包括List和Set，...
实验05 Java集合.doc
06-27
Java集合框架是Java编程语言中一个非常重要的组成部分，它提供了一组高级的数据结构，使得开发者能够更方便地管理和操作对象。在本次实验中，我们主要关注了三个主要的集合接口：Set、List和Map，以及它们的一些常见...
Java集合框架
12-22
Java集合框架是Java编程语言中一个至关重要的组件，它为开发者提供了存储和管理对象的统一方式。集合可以被看作是一个容器，允许我们存放多个对象，并支持常见的操作，如添加、删除和修改元素。 Collection接口是...
java集合框架面试题
11-08
### Java集合框架经典面试题详解 #### 1. Java集合框架概述及优点 - **定义**: Java集合框架是一个设计模式，用于组织和操纵对象集合。它由一系列接口、实现类和算法组成，提供了统一的方式管理和操作数据集合。...
java 集合练习题
07-26
在这个“java集合练习题”中，我们主要关注如何使用Java集合框架来处理数据，特别是对于学生信息的存储、排序和输出。以下是对这个练习题的详细解析： 1. **集合框架简介**： Java集合框架是Java API的一部分，它...
【Java】Java集合框架思维导图。
04-13
xmind格式的Java集合框架学习导图，包括Collection接口/Map接口以及具体实现类。 同样包含大厂面试题，也在导图中有所体现。 能学到什么： 更加成体系的知识框架，更加全面的、系统的知识。 思维导图： 思维导图具有...
Java List<String>为空判断
weixin_34008784的博客
03-25 1155
判断以下数据为空： List<String> list = new ArrayList<String>(); list接收到： list = [] 需要以下判断： if(null != list && !list.isEmpty()){ 　　return; }else{ 　　//继续执行 } isEmpty() 表示为：分配...
lamuda表达式 list移除空元素_删除List所有元素都为空的行数据
weixin_39575047的博客
02-06 930
在查询过程中，可能会遇到查询出行数据都为null的情况，如下图所示： 我们可以采用以下的方法删除全为空的行数据1. 使用原生Java删除空行@Testpublic void testRemoveNullElement() {List list = new ArrayList<>(Arrays.asList(null, 1, null));while (list.remove(null...
JAVA问题总结之23--生成一个长度为100的随机整数list
Keep Learning
09-22 3739
JAVA问题总结之23–生成一个长度为100的随机整数listpackage java9221; import java.util.ArrayList; import java.util.List; public class testlist { public static void main(String[] args) { // TODO Auto-generated me
移除list中所有的""空元素
youarenotin的博客
12-18 2553
移除list中的""空元素 list_1 = [’’, ‘0’, ‘’, ‘s’, ‘’, ‘’, ‘’, ‘’, ‘’, ‘’, ‘6’] print(len(list_1)) for i in list_1: if i == ‘’: list_1.remove(i) else: pass print(list_1) print(len(list_1)) 输出结果 11 [‘0’, ‘s’, ‘...
Java集合框架详解
"Java集合是Java编程中非常重要的部分，涵盖了数据存储和管理的主要机制。这份教程涵盖了Java集合框架的基本概念、接口和类，包括List、Set和Map接口的实现。" 在Java中，集合框架是处理对象组的核心工具，它提供了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值