章六、集合（1）—— Set 接口及实现类、集合迭代、Map 接口、Collections类

一、 Set 接口及实现类

Set接口不能存储重复元素

        Set接口继承了Collection接口。Set中所存储的元素是不重复的,但是是无序的, Set中的元素是没有索引的

Set接口有两个实现类：

        ● HashSet ：HashSet类中的元素不能重复

        ● TreeSet ：可以给Set集合中的元素进行指定方式的排序。存储的对象必须实现Comparable接口。

●  HashSet

import java.util.HashSet;public class HashSetDemo {public static void main(String[] args) {/*Set:元素不重复HashSet：元素是无序的*/HashSet<String> set = new HashSet<>();set.add("a");set.add("b");set.add("c");set.add("a");set.add("d");System.out.println(set);//set.clear();set.contains("a");set.isEmpty();set.remove("a");//没有索引,故而不能用for循环，只能用增强for和迭代器set.size();set.iterator();}
}

HashSet在添加元素时，是如何判断元素重复的：

        当我们向集合中添加一个元素时，如果每次都使用equals()比较内容是否相等，效率会很低
在底层会调用hashCode()方法
-- 在Object中的hashCode()返回的是地址，不能用
-- 而是调用String类中重写的hashCode()方法，返回的是根据内容计算的哈希值

遍历时，会先比较内容的哈希值是否相等，会提高比较的效率，
        但是Hash值会可能存在问题：内容不同，哈希相同（例如“通话”和“种地”的哈希值相同）此种情况下再调用 equals()内容

import javax.xml.transform.Source;
import java.sql.SQLOutput;
import java.util.HashSet;public class HashSetDemo2 {/*HashSet在添加元素时，是如何判断元素重复的:当我们向集合中添加一个元素时，如果每次都使用equals()比较内容是否相等，效率会很低在底层会调用hashCode()方法-- 在Object中的hashCode()返回的是地址，不能用-- 而是调用String类中重写的hashCode()方法，返回的是根据内容计算的哈希值遍历时，会用哈希值先比较是否相等，会提高比较的效率，但是Hash值会可能存在问题，内容不同，哈希相同（例如“通话”和“种地”的哈希值相同）此种情况下再调用 equals()内容*/public static void main(String[] args) {HashSet<String> set = new HashSet<>();set.add("a");set.add("b");set.add("c");set.add("a");set.add("d");System.out.println(set);for (String s : set){System.out.println(s);}}
}

●  TreeSet

        可以给Set集合中的元素进行指定方式的排序。由于这些自定义的类型的数据没有实现Comparable接口，因此无法直接在TreeSet集合中进行排序操作。

解决方案：

        要求TreeSet集合中存储的元素所在的类必须实现Comparable接口，并重写comoareTo()方法，然后TreeSet集合就会对该类型使用compareTo()方法进行比较，并默认进行升序排序

public class Student implements Comparable<Student>{private int num;private String name;public Student() {}public Student(int num, String name) {this.num = num;this.name = name;}public int getNum() {return num;}public void setNum(int num) {this.num = num;}public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic int compareTo(Student o) {int temp = this.num - o.num;return temp == 0 ? this.name.compareTo(o.name) : temp;}}
import java.util.Iterator;
import java.util.TreeSet;/*
放入学生信息
要给自定义数据要实现compareTo接口*/
public class TreeSetDemo2 {public static void main(String[] args) {Student s1 = new Student(20,"张三1");Student s2 = new Student(21,"张三2");Student s3 = new Student(20,"张三3");Student s4 = new Student(23,"张三4");Student s5 = new Student(20,"张三1");TreeSet<Student> treeSet = new TreeSet<>();treeSet.add(s4);treeSet.add(s2);treeSet.add(s3);treeSet.add(s1);treeSet.add(s5);System.out.println(treeSet);}
}

●  Set 接口集合迭代

        • 增强for循环

import java.util.Iterator;
import java.util.TreeSet;/*
放入学生信息
要给自定义数据要实现compareTo接口*/
public class TreeSetDemo2 {public static void main(String[] args) {Student s1 = new Student(20,"张三1");Student s2 = new Student(21,"张三2");Student s3 = new Student(20,"张三3");Student s4 = new Student(23,"张三4");Student s5 = new Student(20,"张三1");TreeSet<Student> treeSet = new TreeSet<>();treeSet.add(s4);treeSet.add(s2);treeSet.add(s3);treeSet.add(s1);treeSet.add(s5);System.out.println(treeSet);Iterator<Student> iterator = treeSet.iterator();for(Student a : treeSet){System.out.println(a.getNum()+a.getName());}}
}

        • 迭代器遍历

二、 Map 接口 ※

将键映射到值的对象

Map接口的特性
数据存储是以 (键,值) 的形式存储
键不能重复，值可以重复
一个键只能映射到一个值

一个映射不能包含重复的键，每个键最多只能映射到一个值，即 值 -> 键 是 一对多 的形式

●  Map 接口常用方法

V put(K key,V value)        //一次向Map里放入一个键值对

V remove(Object key)        //通过键删除

void clear()        //清空 map

boolean containsKey(Object key)

boolean containsValue(Object value)

boolean isEmpty()

int size()

V get(Object key)

Collection<V> values()

Set<K> keySet()

Set<Map.Entry<K,V>> entrySet()

●  HashMap ※

HashMap中元素的key值不能重复， 排列顺序是不固定的，可以存储一个为null的键。

其在存储时到底是什么结构？※

首先用到 Hash数组（查询快，定位快），长度默认为16，创建Hash数组主要是用来定位

        然后通过输入的 key 来计算出一个 int类型 的 hash值（hash%数组长度），然后在该 hash值 的索引处创建一个 Next = NULL 的链表

 

 当下一个 key 计算出来的hash值与存在的相同时（即hash冲突），比较该位置的值，如果不相同，则向下链接新节点（拉链法），即将后来的元素添加到之前元素的Next节点；如果相同，则用后来的键的值覆盖原来的值

当某一hash节点处的链表过长（ >=8 ）时（会影响速度），且哈希数组长度 >=64时，链表会自动转为红黑树

 当哈希表的负载因子为0.75时，会自动扩容为原来数组长度的2倍

         • HashMap方法

import java.util.Collection;
import java.util.HashMap;public class HashMapDemo {public static void main(String[] args) {/*Map接口的特性数据存储是 (键,值)的形式存储键不能重复，值可以重复一个键只能映射到一个值*/HashMap<String,String> map = new HashMap<>();map.put("a","aa"); //(键,值)map.put("b","bb");map.put("w","ww");map.put("c","cc");map.put("d","bb"); //值可以重复map.put("a","aaa"); //用第二次加进的值覆盖了第一次键的值System.out.println(map);//删除指定的键并返回对应的值System.out.println(map.remove("a"));System.out.println(map);//清除 map/*map.clear();System.out.println(map);*///判断map中键值对的个数是否为空System.out.println(map.isEmpty());//判断是否有输入的键System.out.println(map.containsKey("b"));//判断是否有输入的值System.out.println(map.containsValue("bb"));//获得 键的值System.out.println(map.get("b"));//返回map的所有值System.out.println(map.values());}
}

●  TreeMap

TreeMap中所有的元素都保持着某种固定的顺序，如果需要得到一个有序的Map就应该使用TreeMap，key值所在类必须实现Comparable接口。

import java.util.TreeMap;
/*
TreeMap
键可以排序
键元素必须实现 Comparable接口，重写compareTo()*/
public class TreeMapDemo1 {public static void main(String[] args) {TreeMap<Integer,String> treeMap  = new TreeMap<>();treeMap.put(2,"aa");treeMap.put(1,"bb");treeMap.put(3,"aa");treeMap.put(5,"cc");treeMap.put(4,"ee");treeMap.put(2,"bb");System.out.println(treeMap);}
}

 

●  HashTable

/*
        在HashMap中可以存储一个 键 或者 值 为null的对象
        但Hashtable不能存储，会直接报错
*/

 

三、 Map集合遍历

●  根据键找值

• 获取所有键的集合

• 遍历键的集合，获取到每一个键

• 根据键找值

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Traverse1 {public static void main(String[] args) {/*方法一：先拿到所有的键，遍历键，根据键找值*///        Collection<String> values = Map.values();
//        System.out.println(values);HashMap<String,String> map = new HashMap<>();map.put("a","aa");map.put("b","bb");map.put("w","ww");map.put("c","cc");System.out.println(map);//第一种遍历方式Set<String> keyset = map.keySet();for(String key : keyset){System.out.println(key+":"+map.get(key));}}
}

●  根据键值对对象找键和值

• 获取所有键值对对象的集合

• 遍历键值对对象的集合，获取到每一个键值对对象

• 根据键值对对象找键和值

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;public class Traverse1 {public static void main(String[] args) {//        Collection<String> values = Map.values();
//        System.out.println(values);HashMap<String,String> map = new HashMap<>();map.put("a","aa");map.put("b","bb");map.put("w","ww");map.put("c","cc");System.out.println(map);//推荐的遍历方式Set<Map.Entry<String,String>> entries = map.entrySet();for(Map.Entry entry : entries){System.out.println(entry.getKey()+":"+entry.getValue());}}
}

四、 Collections类

Collections是集合类的工具类，与数组的工具类Arrays类似

addAll(Collection<? super T> c , T ... elements);        //向集合中添加一个可变长度的数组

binarySearch(List<? extends Comparable<? super T >> list, T key)

sort(List<T> list)        //根据元素的自然顺序 对指定列表按升序进行排序

sort(List<T> list, Comparator<? super T> c)        //根据指定比较器产生的顺序对指定列表进行排序。

swap(List<?> list, int i , int j)        //在指定List的指定位置 i , j 处交换元素

copy(List<? super T> dest , List<? extends T> src) ;        //将集合复制

// 注意 dest size >= src.size

fill(List<? super T> list, T obj)        //覆盖

max(Collection<? extends T> coll)        //最大值

min(Collection<? extends T> coll)        //最小值

replaceAl l(List<T> list , T oldVal , T newVal)        //用 newVal 覆盖 list 中的 oldVal

reverse(List<?> list)        //反转列表中元素的顺序

shuffle(List<?> list)        //对List集合元素进行随机排序

copy(dest , src)        //集合复制

 addAll（）：向集合中添加一个可变长度的数组

import java.util.*;public class CollectionsDemo1 {public static void main(String[] args) {HashMap<String,String> map = new HashMap<>();map.put("a","aaa");map.put("b","bbb");map.put("c","ccc");map.put("d","ddd");map.put("e","eee");/*addAll(Collection < ? super T > c, T... elements);父类对象（可以传进Collection接口的所有对象）T ... elements ：可变长度的 T类型的参数作用：向集合中添加元素*/ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);Collections.addAll(list,3,4,5,6);System.out.println(list);//test(1,2,3,4);}/*int ... a 可变长度的参数，本质是一个数组一个参数列表中只能有一个可变长度参数且必须放在参数列表最后*/
//    public static void test(int ... a){
//        System.out.println(Arrays.toString(a));
//    }}

sort（）：排序，需要根据元素重写

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class CollectionsDemo2 {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);Collections.addAll(list,3,5,2,4);System.out.println(list);//排序---自定义排序规则//创建了一个实现Comparator接口的匿名内部类对象，就是省去创建一个类，简化了语法Collections.sort(list, new Comparator<Integer>() {@Overridepublic int compare(Integer o1, Integer o2) {return o2.intValue()-o1.intValue();}});Collections.sort(list);System.out.println(list);}
}

copy（）：将原集合的值复制到目标集合

注：目标集合必须非空，且目标集合的size>=原集合

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;public class CollectionsDemo3 {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);list.add(4);System.out.println(list);//交换指定位置上的元素Collections.swap(list,0,1);System.out.println(list);System.out.println();//将一个集合的元素复制到另一个集合去ArrayList<Integer> list1 = new ArrayList<>();//如果目标集合的为空，那copy事会报错list1.add(5);list1.add(6);list1.add(7);//且目标集合的 size >= 原集合的 size，否则报错list1.add(8);Collections.copy(list1,list);System.out.println(list);System.out.println(list1);}
}

其他：

import java.util.ArrayList;
import java.util.Collections;public class CollectionsDemo4 {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();list.add(1);list.add(2);list.add(3);list.add(4);System.out.println(list);//最大值System.out.println(Collections.max(list));//最小值System.out.println(Collections.min(list));//用newVal覆盖oldValCollections.replaceAll(list,3,5);System.out.println(list);Collections.replaceAll(list,5,3);//翻转集合元素顺序Collections.reverse(list);System.out.println(list);//对集合元素随机排序Collections.shuffle(list);System.out.println(list);}
}

 

五、 泛型

        早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

●  什么是泛型

● 泛型，即“参数化类型” 。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。

● 参数化类型，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式，然后在使用/调用时传入具体的类型。

● Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，泛型的好处就是在编译的时候能够检查类型安全。

●  泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口

public class Demo<T>{

/ /T可以为任意标识符，常见的如T、E、K、V等形式的参数常用于表示泛型

        private T key; / /key这个成员变量的类型为T,T的类型由外部指定

        public Demo(T key) {

        / /泛型构造方法形参key的类型也为T，T的类型由外部指定

                this.key = key;

        }

        public T getKey(){ / /泛型方法getKey的返回值类型为T，T的类型由外部指定

                return key;

        }

}

传入的实参类型需与泛型的类型参数类型相同，即为Integer.

1.泛型的类型参数只能是类类型

2.泛型的类型参数可以有多个

3.如果没有定义具体类型,默认为Object

●  从泛型类派生子类

父类：

public class A<T> {T data;
}

子类也是泛型类，子类和父类的泛型类型要一致

class A<T> extends Demo<T> 

/*
父类是泛型类
方法一：直接给子类也定义为泛型类
*/
public class B<T> extends A<T>{public static void main(String[] args) {B b = new B();b.data = "String类型";}
}

子类不是泛型类，父类要明确泛型的数据类型

class A extends Demo<String>

/*
父类是泛型类方法二：若子类不是泛型类，那就要在子类中明确指出父类中的泛型
//public class B extends A<String>{*/public class B extends A<String>{public static void main(String[] args) {B b = new B();b.data = "String类型";}
}

●  泛型接口

泛型接口与泛型类的定义及使用基本相同。

public interface Demo<T> { //定义一个泛型接口 }

子类也是泛型类，子类和父类的泛型类型要一致

class A<T> implements Demo<T>{ }

子类不是泛型类，父类要明确泛型的数据类型

public class A implements Demo<String> { }

●  类型擦除

        泛型是Java 1.5版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛到信息只存在于代码编译阶段，在进入JVM之前，与泛型相关的信息会被擦除掉，我们称之为一类型擦除。

泛型类被类型擦除后，相应的类型就被替换成 Object 类型或者上限类型。

案例:

public class Demo<T>{

        T name;

        public Demo(T name) {

                this.name= name;

         }

}

Demo是一个泛型类，我们查看它在运行时的状态信息可以通过反射。

Demo<String> demo= new Demo<String>("jim");

Field f = eclz.getField(“name”);

System.out.println(f.getName()+" type:"+f.getType());

name type:java.lang.Object

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/527920.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

uglityjs非集成方式混淆js代码

uglityjs非集成方式混淆js代码

文章目录 uglityjs非集成方式混淆js代码一、前言1.简介2.环境3.bat和ps1.ps1 文件.bat 文件 二、正文1.安装Node.js2.安装UglityJS3.代码混淆1&#xff09;单个文件2&#xff09;多个文件 uglityjs非集成方式混淆js代码 一、前言 1.简介 UglifyJS 是一个 JavaScript 解析器、…
阅读更多...
STM32 利用FlashDB库实现在线扇区数据管理不丢失

STM32 利用FlashDB库实现在线扇区数据管理不丢失

STM32 利用FlashDB库实现在线扇区数据管理不丢失 &#x1f4cd;FalshDB地址:https://gitee.com/Armink/FlashDB ✨STM32没有片内EEPROM这样的存储区&#xff0c;虽然有备份寄存器&#xff0c;仅可以实现对少量数据的频繁存储&#xff0c;但是依赖备份电源&#xff08;BAT引脚&a…
阅读更多...
【数据分享】2013-2022年全国范围逐年CO栅格数据（免费获取）

【数据分享】2013-2022年全国范围逐年CO栅格数据（免费获取）

空气质量数据是在我们日常研究中经常使用的数据&#xff01;之前我们给大家分享了2000-2022年全国范围逐年的PM2.5栅格数据和2013-2022年全国范围逐年SO2栅格数据&#xff08;可查看之前的文章获悉详情&#xff09;。 本次我们给大家带来的是2013-2022年全国范围的逐年的CO栅格…
阅读更多...
人民网（人民号）如何发布文章新闻，人民网怎么投稿，附人民日报价格多少钱

人民网（人民号）如何发布文章新闻，人民网怎么投稿，附人民日报价格多少钱

最近有很多朋友问到一个问题&#xff0c;就是人民网如何发布文章新闻&#xff0c;以及人民网怎么投稿。作为一个专业的媒体发稿平台&#xff0c;媒介多多网为大家提供了一个非常好的解决方案。 首先&#xff0c;人民网作为我国权威媒体之一&#xff0c;其新闻发布渠道非常严谨…
阅读更多...
详解前端登录流程：实现原理与最佳实践

详解前端登录流程：实现原理与最佳实践

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…
阅读更多...
Unity使用Addressable热更新

Unity使用Addressable热更新

先看热更新的gif: Addressable是Unity推出的打ab包方案。不需要手动写AB打包脚手架了&#xff0c;不需要关心依赖&#xff0c;这也简化了ab热更新的流程。Addressable打包需要先将资源放入group中&#xff0c;按group来打包&#xff0c;每个group对应一个ScriptableObject的配置…
阅读更多...
VLAN FAQ

VLAN FAQ

如何快速查看所有接口的接口类型和缺省VLAN&#xff1f; 可通过命令display port vlan查看到设备上所有接口的接口类型和缺省VLAN。例如&#xff1a; V200R005及后续版本<HUAWEI> display port vlan Port Link Type PVID Trunk VLAN List --…
阅读更多...
虚拟机实验环境配置与使用（计算机系统2）

虚拟机实验环境配置与使用（计算机系统2）

一、 实验目标&#xff1a; 熟悉Linux上C程序的编译和调试工具&#xff0c;包括以下内容&#xff1a; 1. 了解Linux操作系统及其常用命令 2. 掌握编译工具gcc的基本用法 3. 掌握使用gdb进行程序调试 二、实验环境与工件 1.个人电脑 2. Fedora 13 Linux 操作系统 3. gcc…
阅读更多...
【C语言】【LeetCode】循环队列

【C语言】【LeetCode】循环队列

目录 &#xff08;一&#xff09;题目描述 &#xff08;二&#xff09;数据结构的选择 &#xff08;三&#xff09;函数接口的分析实现 正文开始&#xff1a; &#xff08;一&#xff09;题目描述 题目链接&#xff1a;622. 设计循环队列 设计你的循环队列实现。 循环队列是…
阅读更多...
【设计模式】（四）设计模式之工厂模式

【设计模式】（四）设计模式之工厂模式

1. 工厂模式介绍 工厂模式&#xff08;Factory Pattern&#xff09;是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式&#xff0c;它提供了一种创建对象的最佳方式。 工厂模式有三种实现方式&#xff1a; 简单工厂模式工厂方法模式抽象工厂模式 2. 工厂方…
阅读更多...
【MATLAB第100期】基于MATLAB的多种改进拉丁超立方LHS数据抽样方法

【MATLAB第100期】基于MATLAB的多种改进拉丁超立方LHS数据抽样方法

【MATLAB第100期】基于MATLAB的多种改进拉丁超立方LHS数据抽样方法 一、LHS种类 1、LHS 使用随机搜索生成拉丁超立方体样本。LHS函数特别适用于非常大的设计&#xff0c;当本机MATLAB函数内存不足时。这可能取决于MATLAB版本和所用机器的配置。当尝试运行“lhsdesign”但未成…
阅读更多...
ThreadLocal使用，配合拦截器HandlerInterceptor使用

ThreadLocal使用，配合拦截器HandlerInterceptor使用

ThreadLocal使用&#xff0c;配合拦截器HandlerInterceptor使用 ThreadLocal的使用场景通常涉及多线程环境下需要为每个线程保留独立状态的情况。它提供了一种简单的方式来管理线程本地变量&#xff0c;使得每个线程都可以独立地访问和修改自己的变量副本&#xff0c;而不会影…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023