【笔记】Java的常用工具_集合简介、List集合的特点和应用、增强for的使用、迭代器演示、泛型简介、Collections工具类的使用、Set集合的特点、Map集合的特点和应用一、Java常用工具_集合简介二、List集合的特点和应用三、增强for的使用四、迭代器演示五、泛型简介六、Collections工具类的使用（sort()、max()、reverse()、shuffle()）七、Set集合的特点八、Map集合的特点和应用

109 阅读 0 评论 72 点赞

我是靠谱客的博主丰富泥猴桃，最近开发中收集的这篇文章主要介绍【笔记】Java的常用工具_集合简介、List集合的特点和应用、增强for的使用、迭代器演示、泛型简介、Collections工具类的使用、Set集合的特点、Map集合的特点和应用一、Java常用工具_集合简介二、List集合的特点和应用三、增强for的使用四、迭代器演示五、泛型简介六、Collections工具类的使用（sort()、max()、reverse()、shuffle()）七、Set集合的特点八、Map集合的特点和应用，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

一、Java常用工具_集合简介
- 1.集合概念
- 2.集合和数组的区别
- - （1）元素类型
  - （2）元素个数
  - 集合的好处
- 3.Java的集合体系
- - （1）单列集合（Collection）
  - （2）双列集合（Map：key，value）
二、List集合的特点和应用
三、增强for的使用
四、迭代器演示
- 1、迭代器的常用方法
- 2、迭代器的使用步骤
- 3、列表迭代器
- 4、总结
五、泛型简介
六、Collections工具类的使用（sort()、max()、reverse()、shuffle()）
- 1.Collections简介
- 2.成员方法
七、Set集合的特点
- 总结：
八、Map集合的特点和应用

一、Java常用工具_集合简介

在这里插入图片描述

1.集合概念

简称集，是用来存储多个元素的容器

2.集合和数组的区别

（1）元素类型

集合：引用类型（存储基本类型时自动装箱）
数组：基本类型、引用类型

（2）元素个数

集合：不固定，可以任意扩容
数组：固定，不能改变容量

集合的好处

① 不受容器大小限制，可以随时添加、删除元素
② Java提供了大量操作元素的方法（判断、获取等）

3.Java的集合体系

（1）单列集合（Collection）

List（接口）：（该接口拥有很多子类）最常见的子类是ArrayList
Set（接口）：（该接口拥有很多子类）最常见的子类是HashSet

（2）双列集合（Map：key，value）

Map（接口）：（该接口拥有很多子类）最常见的子类是HashaMap

在这里插入图片描述

二、List集合的特点和应用

特点：
可重复、有序（存取顺序相同）

应用：(父接口指向子类对象)
List list = new ArrayList();

例：List集合的简单使用
在这里插入图片描述

Student类部分代码：

package Demo;

//学生类
public class Student {
    //成员变量
    private String name;
    private int age;

    //空参构造
    public Student() {
    }
    //全参构造
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    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 "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

Main（主方法）类部分代码：

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //需求：在List中添加3个学生对象，然后遍历
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        Student s1 = new Student("张三",21);
        Student s2 = new Student("张三",21);//验证可重复性
        Student s3 = new Student("王二",25);
        Student s4 = new Student("老王",21);
        //3.将元素对象添加到集合对象中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        list.add(s4);

        //直接打印集合
        System.out.println(list);
        //获取索引为2的集合
        Object obj = list.get(2);
        System.out.println("索引为2的元素时："+obj);
        //获取集合中的元素个数
        System.out.println("元素中的集合个数为："+list.size());
        System.out.println("--------------------------");
        //4.遍历集合
        for(int i = 0;i < list.size();i++) {
            Object obj2 = list.get(i);
            System.out.println("索引为："+i+"的元素是："+obj2);
        }
    }
}

运行结果：
在这里插入图片描述

三、增强for的使用

增强for循环的作用：简化数组和集合的遍历

增强for循环的格式：
在这里插入图片描述
例：使用增强for循环遍历List集合

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //需求：通过增强for循环遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add(10);
        list.add(10);
        list.add(30);
        list.add(20);
        list.add(40);
        //4.遍历集合
        for(Object obj:list) {
            //obj是集合中的元素，其本身应该是Integer类型的数据
            Integer ii = (Integer)obj;
            System.out.println(ii);
        }
        System.out.println("--------------");
        for (Object obj : list) {
            System.out.println(obj);
        }
    }
}

运行结果：
在这里插入图片描述

补充，IDEA快捷键iter，回车，会出现增强for循环
解释（为什么是iter）：增强for的底层依赖是迭代器（Iterator）/换言之，增强for就是迭代器的简写形式。

四、迭代器演示

迭代：对过程的重复，称为迭代
迭代器：迭代器是遍历Collection集合的通用方式，可以在对集合遍历的同时进行添加、删除等操作。

1、迭代器的常用方法

next(): 返回迭代的下一个元素对象
hasNext(): 如果仍有元素可以迭代，则返回true

2、迭代器的使用步骤

1.根据集合对象获取对应的迭代器对象
2.判断迭代器中是否有元素
3.如果有就获取元素

例：使用迭代器遍历List集合

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        //4.遍历集合
        //迭代器的用法：
        //1.根据集合对象获取其对象的迭代器对象
        Iterator it = list.iterator();
        //2.判断迭代器中是否有元素
        while(it.hasNext()) { //如果迭代器中有元素，就一直迭代
            //3.如果有，就获取元素
            String s = (String) it.next();//因为在集合中添加的都是字符串，因此可以在这里向下转型为String
            System.out.println(s);
        }
    }
}

运行结果：
在这里插入图片描述
例：基于上例，判断集合中如果有字符串”b“，就在其后边添加一个新的字符串：java

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        //4.遍历集合
        //迭代器的用法：
        //判断集合中如果有字符串”b“，就在其后边添加一个新的字符串：java
        //1.根据集合对象获取其对象的迭代器对象
        Iterator it = list.iterator();
        //2.判断迭代器中是否有元素
        while(it.hasNext()) { //如果迭代器中有元素，就一直迭代
            //3.如果有，就获取元素
            String s = (String) it.next();//因为在集合中添加的都是字符串，因此可以在这里向下转型为String
            if ("b".equals(s)) { //这样写可以规避：空指针异常 另一种写法：s.equals("b")
                //能走到这里，说明集合中有元素b
                list.add("java");//这样写会报错ConcurrentModificationException(并发修改异常)
                //意思就是在遍历集合的同时，添加或修改元素，就会出现并发性错误
            }
        }
    }
}

！！！此代码会报错，优化改进方法看下个例子
在这里插入图片描述

3、列表迭代器

列表迭代器是List体系独有的遍历方式，可以在对集合遍历的同时进行添加、删除等操作，但是必须通过调用列表迭代器的方法来实现

例：列表迭代器。判断集合中如果有字符串”b“，就在其后边添加一个新的字符串：java

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //需求：通过迭代器遍历List集合
        //1.创建集合对象
        List list = new ArrayList();
        //2.创建元素对象
        //3.将元素对象添加到集合对象中
        list.add("a");
        list.add("b");
        list.add("c");
        //需求：判断集合中如果有字符串”b“，就在其后边添加一个新的字符串：java
        //1.根据集合对象获取列表迭代器对象
        ListIterator lit = list.listIterator();
        //2.判断迭代器中是否有元素
        while(lit.hasNext()) {
            //3.有就获取元素即可
            String s = (String)lit.next();
            if("b".equals(s)) {
                //list.add("java"); //这样写不行，必须调用列表迭代器的方法来实现
                lit.add("java");
            }
            System.out.println(s);
        }
        System.out.println("------------------");
        //打印新的集合中的值
        System.out.println(list);
    }
}

运行结果：
在这里插入图片描述
上面的程序正在迭代（迭代的时候集合中只有三个元素），而下面的程序是迭代结束后又加了一个“java”值。

4、总结

1.普通的迭代器在遍历集合的同时不能添加或者删除元素，否则会报错（并发修改异常）
2.列表迭代器在遍历集合的同时可以修改集合中的元素（添加，删除等），必须使用列表迭代器中的方法。

五、泛型简介

泛型：即泛指任意类型，又叫参数化类型，对具体类型的使用起到辅助作用，类似于方法的参数。

泛型的好处：类型安全、避免了类型转换

集合类泛型的解释：表示该集合中存放指定类型的元素

例：给List集合中存放指定类型的元素
在这里插入图片描述

package Demo;

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

public class Main {
    public static void main(String[] args) {
       //需求：演示泛型
        List<String> list2 = new ArrayList<>();
        list2.add("a");
        list2.add("b");
        list2.add("c");
        //遍历
        for(String s:list2) {
            System.out.println(s);
        }
    }
}

运行结果：
在这里插入图片描述
总结：
**1.**泛型一般只和集合类相结合使用
**2.**泛型是JDK5的新特性，但从JDK7开始，后边的泛型可以不用写具体的数据类型了（菱形泛型）

六、Collections工具类的使用（sort()、max()、reverse()、shuffle()）

1.Collections简介

针对集合进行操作的工具类

2.成员方法

在这里插入图片描述
例：Collections工具类的使用

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //1.创建集合对象
        List list = new ArrayList<>();
        //2.创建元素对象并往集合中添加数据
        list.add(1);
        list.add(3);
        list.add(5);
        list.add(2);
        list.add(4);
        //3.打印集合
        System.out.println("没有操作以前，集合中的数据是："+list);

        //获取集合中最大元素
        Integer max = (Integer) Collections.max(list);
        System.out.println("集合中的最大元素为："+max);
        System.out.println("---------------------");

        //对集合进行升序排列
        Collections.sort(list);
        System.out.println("升序排列后的结果为："+list);
        System.out.println("------------------------");

        //对升序排列后的集合中的数据进行反转
        Collections.reverse(list);
        System.out.println("反转以后集合中的数据为："+list);
        System.out.println("----------------");

        //随机置换，相当于洗牌
        Collections.shuffle(list);
        System.out.println("最极致换后的结果为："+list);
    }
}

运行结果：
在这里插入图片描述

七、Set集合的特点

特点：不可重复、无序

set是接口，所以要创建它的子类对象，即HashSet类对象

例：Set集合的简单使用
在这里插入图片描述

Student类部分代码

package Demo;

//学生类
public class Student {
    //成员变量
    private String name;
    private int age;

    public Student() {
    }

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

    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 "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }
}

Main（主方法）部分代码

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //创建集合对象
        Set<Student> set = new HashSet<>();
        //创建元素对象并将元素对象添加到集合中
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",23);
        Student s3 = new Student("张三",21);
        Student s4 = new Student("老王",28);
        Student s5 = new Student("李四",23);

        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);

        //遍历集合
        System.out.println(set);
    }
}

运行结果：
在这里插入图片描述
从打印结果来看，为什么Set集合没有去重 ？
因为Set集合保证元素的唯一性依赖：equals()和hashCode()两个方法，
我们没有在Student类中重写这两个方法，默认调用的是Object类中的这两个方法，
而Object类中的equals()方法默认比较的是地址值是否相同。

解决方法：在Student类中重写equals()和hashCode()方法

改进后的代码：

Student类部分代码

package Demo;

import java.util.Objects;

//学生类
public class Student {
    //成员变量
    private String name;
    private int age;

    public Student() {
    }

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

    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 "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Main（主方法）部分代码

package Demo;

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

public class Main {
    public static void main(String[] args) {
        //创建集合对象
        Set<Student> set = new HashSet<>();
        //创建元素对象并将元素对象添加到集合中
        Student s1 = new Student("张三",21);
        Student s2 = new Student("李四",23);
        Student s3 = new Student("张三",21);
        Student s4 = new Student("老王",28);
        Student s5 = new Student("李四",23);

        set.add(s1);
        set.add(s2);
        set.add(s3);
        set.add(s4);
        set.add(s5);

        //遍历集合
        System.out.println(set);  //体现了无序性
        System.out.println("----------------------");

        //通过迭代器遍历Set集合
        //1.通过集合对象获取其对应的迭代器对象
        Iterator<Student> it = set.iterator();
        //2.判断迭代器中是否有元素
        while (it.hasNext()) {
            //3.如果有，就获取元素
            Student s = it.next();
            System.out.println(s);
        }
        System.out.println("----------------------");

        //通过增强for遍历集合
        System.out.println("通过增强for遍历Set集合");
        for (Student student : set) {
            System.out.println(student);
        }
    }
}

运行结果：
在这里插入图片描述

总结：

Set集合保证元素的唯一性依赖：equals()、hashCode()两个方法

八、Map集合的特点和应用

特点：
双列集合，元素由键值对（Entry）构成：key–value key不可以重复，value可以重复，即Map集合的键具有唯一性

应用：
1.Map集合是一个接口，所以要通过创建它的子类对象来完成Map对象的初始化
在这里插入图片描述
2.Map是双列集合，因此泛型要写两个
T1表示键的类型，T2表示值的类型

例：Map集合的简单使用
在这里插入图片描述

Student类部分代码：

package Demo;

import java.util.Objects;

//学生类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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 "Student{" +
                "name='" + name + ''' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

Main类（主方法）部分代码：

package Demo;

import java.util.*;

public class Main {
    public static void main(String[] args) {
        //需求：往Map集合中添加3个学生对象，然后打印
        //创建集合对象
        //键：学生的编号，值：具体的学生对象
        Map<Integer,Student> map = new HashMap();
        //创建元素对象
        Student s1 = new Student("张三",23);
        Student s2 = new Student("李四",25);
        Student s3 = new Student("张三",23);
        //将元素对象添加到集合中
        map.put(1,s1);
        map.put(2,s2);
        map.put(3,s3);

        //根据键，获取值
        Student stu3 = map.get(2);
        System.out.println("key:"+2+"value:"+stu3);
        //打印集合
        System.out.println(map);

        //遍历集合：注意，双列集合是不能直接遍历的，需要转换为单列集合再来遍历
        //1.获取所有键的集合：keySet()
        Set<Integer> keys = map.keySet();
        //2.遍历所有的键，获取到每一个键：迭代器，增强for
        //获取迭代器对象
        Iterator<Integer> it = keys.iterator();
        while (it.hasNext()) {
            //如果迭代器中有数据，就获取
            Integer key = it.next();
            //根据键获取值  get()
            Student value = map.get(key);
            System.out.println("key:"+key+"...value:"+value);

            //通过增强for实现
            //获取到所有键
            Set<Integer> keys1 = map.keySet();
            for (Integer integer : keys1) {
                //key就是双列集合中的每一个键
                Student stu = map.get(key);
            }

        }

    }
}

运行结果：
在这里插入图片描述

最后

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：Java学习笔记
浏览次数：109 次浏览
发布日期：2023-07-25 18:50:03
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_22_f1_14__7__10_5.html

基于MATLAB的二进制数字调制与解调信号的仿真——2FSK

matlab 双二进制信号脉冲_国家级精品课：数字信号处理

java遍历数组与集合之增强for循环前言必读

matlab读二进制文件代码,[Matlab+C/C++] 读写二进制文件

【笔记】Java的常用工具_集合简介、List集合的特点和应用、增强for的使用、迭代器演示、泛型简介、Collections工具类的使用、Set集合的特点、Map集合的特点和应用一、Java常用工具_集合简介二、List集合的特点和应用三、增强for的使用四、迭代器演示五、泛型简介六、Collections工具类的使用（sort()、max()、reverse()、shuffle()）七、Set集合的特点八、Map集合的特点和应用

概述

文章目录

一、Java常用工具_集合简介

1.集合概念

2.集合和数组的区别

（1）元素类型

（2）元素个数

集合的好处

3.Java的集合体系

（1）单列集合（Collection）

（2）双列集合（Map：key，value）

二、List集合的特点和应用

三、增强for的使用

四、迭代器演示

1、迭代器的常用方法

2、迭代器的使用步骤

3、列表迭代器

4、总结

五、泛型简介

六、Collections工具类的使用（sort()、max()、reverse()、shuffle()）

1.Collections简介

2.成员方法

七、Set集合的特点

总结：

八、Map集合的特点和应用

最后

评论列表共有 0 条评论

发表评论取消回复

概述

文章目录

一、Java常用工具_集合 简介

1.集合概念

2.集合和数组的区别

（1）元素类型

（2）元素个数

集合的好处

3.Java的集合体系

（1）单列集合（Collection）

（2）双列集合（Map：key，value）

二、List集合的特点和应用

三、增强for的使用

四、迭代器演示

1、迭代器的常用方法

2、迭代器的使用步骤

3、列表迭代器

4、总结

五、泛型简介

六、Collections工具类的使用（sort()、max()、reverse()、shuffle()）

1.Collections简介

2.成员方法

七、Set集合的特点

总结：

八、Map集合的特点和应用

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

一、Java常用工具_集合简介

发表评论取消回复