精华内容
下载资源
问答
  • Java----泛型与集合
    千次阅读
    2022-03-14 19:05:12

    一、泛型

    1、泛型的安全机制
    泛型作用:强制了集合存储固定的数据类型
    2、书写格式

    //集合类<>
    

    3、泛型的好处

    ①安全性提高了
    ②程序代码量减少
    ③避免了强制类型转换
    ④程序的问题提前到了运行前

    4、泛型中的E

    E没有实际价值,只是一个变量
    特殊:等待接收指定的数据类型

    ArrayList<String> ar = new ArrayList<String>();
    //此时E变成String类型
    

    5、自定义泛型类

    public class MyGe<MY> {
        private MY i;
        public void setI(MY i){
            this.i = i;
        }
        public MY getI(){
            return  i;
        }
    }
    
    public class GeTest {
        public static void main(String[] args) {
            MyGe<String> my = new MyGe<String>();
            my.setI("my");
            String str = my.getI();
            System.out.println(str);
        }
    }
    

    6、自定义泛型方法

        //非静态方法
        public void print(MY my){
            System.out.println(my);
        }
        //静态自定义泛型方法
            public static <A>void print1(A a){
            System.out.println(a);
        }
    

    说明

    1、静态方法参数中的泛型,不能和类一样
    2、静态方法的泛型,需要在方法上单独定义
    3、定义写在返回值类型前面

    7、泛型接口
    方法1:

    //定义接口
    public interface In <A>{
        public abstract void print2(A a);
    }
    
    //实现类实现接口重写方法
    public class GeTest2<A> implements In<A>{
        public void print2(A a){
            System.out.println(a);
        }
    }
    
    //调用实现类
    public class Test1 {
        public static void main(String[] args) {
            In<String> in = new GeTest2<String>();
            in.print2("abc");
        }
    }
    

    方法2

    //泛型接口的使用方法2
    public class GeTest3 implements In<String>{
        public void print2(String s){
            System.out.println(s);
        }
    }
    

    8、泛型通配符

    public static void ha(List<?> list){
            
    }
    //<?>表示通配符:可以传任何类型
    

    9、泛型限定
    泛型限定:限制的是数据类型

    <? extends Company>传递类型可以是Company或者是其他子类 <? extends E>传递E类型或者是E的子类,泛型上限限定 <? super E>传递E类型或者是E的父类,泛型下限限定

    二、Map集合

    1、Map接口方法

    1、V put(k,v)存储键值对,存储重复键,返回被覆盖之前的值
    2、V get(K)通过键获取值,参数传递键,找这个键对应的值,没有这个键返回null
    3、boolean containsKey(K)判断集合是否包含这个键,返回true
    4、boolean containsValue(V)判断集合是否包含这个值,返回true
    5、int size()返回集合长度,Map集合中键值对的个数
    6、V remove(K)移除指定键值对,返回被移除之前的值
    7、Collectionvalues() Map集合中所有的值拿出,存储到Collection集合

    2、Map集合的遍历-键值对映射关系

    1、Map接口的方法Set<Map.Entry<Key.Value>>entrySet()
    方法返回Set集合,集合中存储的元素,比较特别
    存储的是Map集合中,键值对映射关系的对象,内部接口Map.Entry
    2、遍历Set集合
    3、取出Set集合的元素
    是Map.Entry接口对象
    接口对象方法:getKey(),getValue()

    三、HashMap集合特点

    1、哈希表结构
    2、保证键的唯一性,用于键的对象,必须重写hashCode,equals方法
    3、集合允许使用null,作为键或值

    四、LinkedHashMap集合

    继承于HashMap集合实现Map接口,LinkedHashMap底层事项原理是哈希表,双向链,存储有序,特性和HashMap一样

    五、Hashtable

    特点

    底层是哈希表
    线程安全,运行速度慢被HashMap取代
    不允许null的值和键

    六、TreeMap

    特点

    1、底层是红黑树结构
    2、存储到TreeMap中元素,对键进行排序
    3、排序依据

    对象的自然顺序,作为键的对象,实现了接口Comparable
    自己提供比较器,实现家接口Comparator,优先级高

    七、Properties

    继承Hashtable,实现Map接口
    底层是哈希表
    线程是安全的运行速度慢
    集合没有泛型的写法,键和值的数据类型是String类型
    集合有自己的特有方法
    此集合可以和IO流对象结合使用,实现数据的持久存储

    更多相关内容
  • Java 泛型与集合知识点总结 泛型 泛型的应用 在编译时通过一个标识表示类中某个 属性/方法/参数 的类型 编译时,检查添加元素的类型,提高安全性 减少类型转换的次数,提高效率 泛型的语法 1.泛型的声明 泛型类 ...

    Java 泛型与集合知识点总结

    泛型

    泛型的应用

    • 在编译时通过一个标识表示类中某个 属性/方法/参数 的类型
    • 编译时,检查添加元素的类型,提高安全性
    • 减少类型转换的次数,提高效率

    泛型的语法

    1.泛型的声明

    • 泛型类

      class 类名<K, V> {}

      interface 接口 {}

    • 泛型方法

    • 泛型方法可以定义于普通类或泛型类(区别方法使用泛型)

      public static T getMiddle(T… a) { }

    2.泛型的使用

    • 实例化

      在类名后面指定类型参数的值(类型):

      List strList = new ArrayList ();

    • 调用泛型方法

      调用泛型方法时,可以把<具体类型> 放在方法名前面

      类.getMiddle()

    泛型使用细节

    • 参数类型只能是引用类型,不能是基本类型

    • 不能创建参数化类型的数组

    • 在给泛型指定具体类型后,可以传入该类型或者其子类类型

    • 没有指定类型是,默认泛型是 Object

    • 静态方法不能使用类的泛型

      静态和类相关,类加载时,对象还没创建,如果静态方法使用了类的泛型,JVM 就无法完成初始化

    • 泛型不具备继承性

      List<Object> list = new ArrayList<String>(); error

    通配符

    • <?> : 表示支持任意泛型
    • <? extends A>: 支持A 类及A 类的子类,规定了泛型的上限
    • <? super A>: 支持A 类及A 类的父类,不限于直接父类,规定了泛型的下限

    Todo(待补充)

    • 类型擦除(伪泛型)

    集合

    集合框架体系

    集合框架体系图

    迭代器 Iterator

    • next(), hasNext(), remove()

    • 可以认为Java迭代器位于两元素之间

      当调用next 时,迭代器越过下一个元素,并返回越过的元素的引用,remove方法则删除上一次调用next返回的元素

    Collection 接口

    • 有些Collection的实现类可以存放重复元素,有些不可以
    • Collection的实现接口 List 是有序的, Set 是无序的
    • Collection 没有直接的实现子类,是通过它的子接口List 和 Set 来实现的
    • Collection接口的元素遍历方式

      • 1.使用迭代器Iterator
      • 2.增强for循环(简化版的iterator)

    List 接口

    • List集合类中元素有序,且可重复
    • List集合支持索引
    • 常用方法
      • void add(int i, E element)
      • void addAll(int i, Collection<? extends E> elements)
      • E remove(int i) //删除指定位置元素并返回该元素
      • E get(int i)
      • E set(int i, E element)
      • int indexOf(Object element)
      • int lastIndexOf(Object element)
    • List 接口的元素的遍历方式

      • 1.iterator迭代器
      • 2.增强for
      • 3.普通for + 索引

    List 实现类 ArrayList

    • 底层维护的是一个动态的数组
    • 线程不安全的, Vector与其基本等同,除了Vector是线程安全的
    • 创建和扩容流程 Debug
      • 调用无参构造器时,车市elementData容量为零,第一次添加元素时扩容为10, 若再次扩容,则扩容1.5倍
      • 调用有参构造器时指定容量,则出书elementData容量为所指定的大小,若再次扩容,也是扩容1.5倍

    List 实现类 LinkedList

    • 底层维护了一个双向链表
    • LinkedList中维护了两个属性first, last分别指向 首节点和尾节点
    • 添加和删除效率高

    Set 接口

    • Set集合类中元素无序,且不允许重复,最多只能有一个null
    • Set集合类不能通过索引获取
    • Set 接口的元素遍历方式

      • iterator 迭代器
      • 增强for

    Set接口实现类 HashSet

    • 底层是 HashMap(value 值都为空)
    • 不保证顺序,更具hashcode确定索引
    • 不能有重复元素,且只能有一个null

    Set接口实现类 LinkedHashSet

    • 是HashSet子类
    • 底层是LinkedHashMap,维护了一个数组 + 双向链表
    • 根据hashCode确定元素的存储位置,同时使用链表维护元素的次序

    Queue 接口

    • 双端队列Deque接口
    • ArrayDeque和LinkedList类实现了Deque接口
    • 常用方法
      • add()
      • offer()

      入队,将给定元素添加到队列的队尾,如果成功就返回true,若队列已满,add会抛出异常,offer会返回false

      • remove()
      • poll()

      出队,若队列不为空,删除并返回队列头的元素,若空队列,remove抛出异常,poll返回null

      • element()
      • peek()

      返回队列头元素但不删除,若空队列,第一个抛出异常,第二个方法返回null

    Map 接口

    • Map 与Collection 并列存在,用于保存具有映射关系的元素
    • key 和 value 可以是任意引用类型的数据
    • key不允许重复,value可以重复
    • key和value都可以为null,但key中只能有一个null
    • 常用String类作为key
    • Map 接口元素的遍历方式

      • map.keySet() -> 返回所有的key,再通过map.get(key)获取value
        • 增强for
        • 迭代器
      • 取出所有的values map.values()
        • 增强for
        • 迭代器
      • 通过EntrySet获取 k-v (Map.Entry<K, V>) ==》 Set set = map.entrySet()
        • 增强for
        • 迭代器

        Map.Entry 提供的 getKey() 和 getValue()

    Map接口的实现类 HashMap

    • 底层维护的是 数组 + 链表 + 红黑树
    • 线程不安全
    • 若添加相同的Key,会覆盖原来的Value
    • 底层机制 Debug
      • 1.HashMap底层维护了Node类型的数组table,默认为null
      • 2.创建对象是,加载因子初始化为0.75
      • 3.添加Key-Value时,通过Key的哈希值得到在table的索引,判断该索引处是否有元素,若无,直接添加;若有,比较两个Key是否相等,若相等,替换value;若不相等还需要判断是树结构还是链表结构,做出相应处理。如果添加时发现容量不足,需要扩容。
      • 4.第一次添加时table数组初始化容量为16,临界值时12(16*0.75),大于等于临界值时扩容
      • 5.以后在次扩容时table扩容为初始的两倍,临界值也发生改变
      • 6.Java8中,如果一条链表元素超过TREEIFY_THRESHOLD(默认8),并且数组table大于等于MIN_TREEIFY_CAPACITY(默认64)时,将树华为红黑树,如果数组大小不满足,则数组扩容

    Map接口的实现类 HashTable

    • 线程安全的
    • Key和Value都不能为null

    Map接口的实现类 Properties

    • 继承自HashTable
    • 用于读取.properties配置文件

    Collections 工具类

    • 用于操作Set、List、Map等集合的工具类
    • 提供一系列静态方法对集合中元素进行排序、查询和修改等操作
    展开全文
  • 10 * Map接口的主要方法 方法名 功能说明 Object put(Object key,Object value) 插入新的对象并用key作为其键字 void putAll(Map t) 将另一个Map中的所有对象复制进来 Set entrySet) 返回映射中的关键字值对的集合 ...
  • 在jdk1.2之后Java提供了实现常见数据结构的类这些实现数据结构的类通称为Java集合框架在JDK1.5后Java集合框架开始支持泛型本章首先介绍泛型然后讲解常见数据结构类的用法 ;13.1 泛型 ;13.1.1 泛型类声明 ;13.1.2 ...
  • Java泛型集合

    2016-04-22 16:13:15
    Java Generics and Collections 英文版,详细描述java 泛型技术
  • JAVA泛型与集合框架PPT课件PPT学习教案.pptx
  • Java泛型集合.pdf

    2011-09-26 15:16:29
    [Java泛型集合].(Java.Generics.and.Collections).Maurice.Naftalin&Philip.Wadler.文字版.pdf
  • 1、容器类  JDK API中专门设计用来存储其他对象的类,一般称为对象容器类,简称容器类,这组类和接口的设计结构也被统称为集合框架(Collection ...  2、泛型  应用背景:存入容器的对象在取出时需要强制转换类
  • 泛型与集合一、泛型1.泛型定义2.泛型的限制二、集合概述1.集合框架2.迭代器接口三、集合类1.Collection接口2.List 接口及其实现类3.Set 接口及其实现类4.Queue 接口及其实现类5.Map 接口及其实现类四、集合转换...


    一、泛型

    1.泛型定义

    泛型是将数据类型参数化,即在编写代码时将数据类型定义成参数,这些类型参数在使用之前再进行指明。
    泛型提高了代码的重用性,使得程序更加灵活、安全和简洁。

    JDK 5.0之前,为了实现参数类型的任意化,都是通过Object类型来处理,缺点:代码臃肿,需要进行强制类型转换,参数类型必须已知,否则容易引起ClassCastException异常。
    JDK 5.0之后,Java增加对泛型的支持,解决以上缺点。泛型经常在类、接口和方法的定义中,分别称为泛型类、泛型接口和泛型方法。

    在这里插入图片描述
    GenericDemo.java:

    class Generic <T>{
        private T data;
        public Generic(){
        }
         public Generic(T data){
    	this.data = data;
        }
        public T getData(){
    	return data;
        }
         public void setData(T data){
    	this.data = data;
        }
        public void showDataType(){
    	//获取对象的类名并打印输出
    	System.out.println("数据的类型是:"+data.getClass().getName());
        }
    }
    public class GenericDemo{
        public static void main(String[] args){
    	//采用带参数的构造方法实例化泛型对象
    	Generic <String> strObj = new Generic <String>("欢迎使用泛型类");
    	strObj.showDataType();
    	System.out.println(strObj.getData());
    	System.out.println("--------------------------------");
    	Generic <Double> dObj = new Generic <>(3.1415);
    	dObj.showDataType();
    	System.out.println(dObj.getData());
    	System.out.println("--------------------------------");
    	Generic <Integer> intObj = new Generic <>(123);
    	intObj.showDataType();
    	System.out.println(intObj.getData());
    	System.out.println("--------------------------------");
        }
    }
    
    

    2.泛型的限制

    (1)实例化泛型时,类型参数只能是类类型(包括自定义类),如String、Integer等,不能是简单类型。
    (2)同一个泛型类可以有多个版本(不同参数类型),不同版本的泛型类的实例是不兼容的,例如Generic 与Generic 的实例是不兼容的。
    (3)定义泛型时,类型参数只是占位符,不能直接实例化,例如“new T()”是错误的。
    (4)不能实例化泛型数组。
    (5)泛型类不能继承Throwable及其子类,即泛型类不能是异常类

    二、集合概述

    Java的集合类是一些常用的数据结构,如队列、栈、链表等。
    Java集合就像一种“容器”,用于存储数量不等的对象,并按照规范实现一些常用的操作和算法。

    1.集合框架

    Java所有集合类都在java.util包下,
    Java集合类主要有两个接口派生而成:Collection和Map,这两个接口是集合框架的根接口
    NoteBook.java:

    import java.util.ArrayList;
    public class NoteBook{
        private ArrayList<String> notes = new ArrayList<String>();//ArrayList是有序列表
        public void add(String s){
    	notes.add(s);//添加数据
        }
        public int getSize(){
    	return notes.size();//获取数据条数
        }
        public String getNote(int index){
    	return notes.get(index);//根据下标找到数据
        }
        public void removeNote(int index){
    	notes.remove(index);//删除下标为index的数据
        }
        public String[] list(){
    	String a[] = new String[notes.size()];
    	for(int i=0;i<notes.size();i++){
    	    a[i] = notes.get(i);
    	}
    	return a;
        }
        public static void main(String[] args){
    	NoteBook nb = new NoteBook();
    	nb.add("first");
    	nb.add("second");
    	nb.add("third");
    	System.out.println(nb.getSize());
    	System.out.println(nb.getNote(1));
    	nb.removeNote(1);
    	String[] a = nb.list();
    	for(String s:a)//获取数组a的每一个值并赋给s
    	{
    	    System.out.println(s);
    	}	
        }
    }
    

    使用迭代器后:

    import java.util.ArrayList;
    import java.util.Iterator;
    public class NoteBook{
        private ArrayList<String> notes = new ArrayList<String>();
        public void add(String s){
    	notes.add(s);
        }
        public int getSize(){
    	return notes.size();
        }
        public String getNote(int index){
    	return notes.get(index);
        }
        public void removeNote(int index){
    	notes.remove(index);
        }
        public void list(){
    	Iterator<String> iterator = notes.iterator();
    	while(iterator.hasNext()){
    	   System.out.println(iterator.next());
    	}	
        }
        public static void main(String[] args){
    	NoteBook nb = new NoteBook();
    	nb.add("first");
    	nb.add("second");
    	nb.add("third");
    	System.out.println(nb.getSize());
    	System.out.println(nb.getNote(1));
    	nb.removeNote(1);
    	nb.list();
        }
    }
    

    两种方式的运行结果一致如下:
    (注意:默认下标从0开始)
    在这里插入图片描述

    2.迭代器接口

    迭代器(Iterator):可以采用统一的方式对Collection集合中的元素进行遍历操作该接口是Collection接口的父接口。
    方法:
    boolean hasNext():判断是否有下一个可访问的对象,有返回true,没有返回false。
    E next():返回可访问的下一个元素。
    void remove():移除迭代器返回的最后一个元素,该方法必须紧跟在一个元素的访问后执行。

    三、集合类

    1.Collection接口

    Collection接口是Set、Queue和List接口的父接口。该接口中的方法可以操作这三个接口中的任一个集合。由接口的特点可知,其内部的方法都是抽象方法,在应用时需要重写。
    在这里插入图片描述
    在这里插入图片描述
    注意:
    (1)add()、addAll()、remove()、removeAll()和retainAll()方法可能会引发不支持该操作的UnsupportedOperationException异常。
    (2)将一个不兼容的对象添加到集合中,将产生ClassCastException异常。
    (3)Collection接口没有提供获取某个元素的方法,但可以通过iterator()方法获取迭代器来遍历集合中的所有元素
    (4)虽然Collection中可以存储任何Object对象,但不建议在同一个集合容器中存储不同类型的对象,建议使用泛型增强集合的安全性,以免引起ClassCastException异常。

    2.List 接口及其实现类

    List接口:有序、可重复的集合,与数组类似,List集合可以记住每次添加元素的顺序,因此可以根据元素的索引访问List集合中的元素,元素可以重复且长度是可变的(相当于可变长数组)。
    ArrayList(数组列表)和Vector(向量)是List接口的两个典型实现类,两者功能类似,推荐使用前者。

    ArrayListDemo.java:

    import java.util.*;
    public class ArrayListDemo{
        public static void main(String[] args){
    	ArrayList <String> list = new ArrayList <>();
    	//向集合中添加元素
    	list.add("北京");
    	list.add("上海");
    	list.add("天津");
    	list.add("济南");
    	list.add("青岛");
    	//错误,只能添加字符串
    	//list.add(1);//错误原因:不同版本的泛型类的实例是不兼容的
    	//使用foreach语句遍历
    	System.out.println("使用foreach语句遍历");
    	for(String e:list){
    		System.out.println(e);
    	}
    	System.out.println("---------------------");
    	System.out.println("使用迭代器遍历:");
    	//获取ArrayList的迭代器
    	Iterator <String> iterator = list.iterator();
    	//使用迭代器遍历
    	while(iterator.hasNext()){
    		System.out.println(iterator.next());
    	}
    	System.out.println("---------------------");
    	//删除下标索引是1的元素,即第二个元素“上海”
    	list.remove(1);
    	//删除指定元素
    	list.remove("青岛");
    	System.out.println("删除后剩下的数据:");
    	for(String e:list){
    		System.out.println(e);
    	}
        }
    }
    
    

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

    3.Set 接口及其实现类

    Set接口:类似一个罐子,将一个对象添加到Set集合时,Set集合无法记住添加的顺序,因此Set集合中的元素不能重复。
    常用的实现类:HashSet、TreeSet、EnumSet。
    **HashSet:**大多数使用Set集合时都使用该实现类,HashSet使用Hash算法来存储集合中的元素,具有良好的存、取以及可查找性。
    **TreeSet:**采用“树”的数据结构来存储集合元素,可保证几何中的元素处于排序状态。
    **EnumSet:**专为枚举类设计的集合类,所有元素必须是指定的枚举类型。

    HashSetDemo.java:

    import java.util.HashSet;
    import java.util.Iterator;
    public class HashSetDemo{
        public static void main(String[] args){
    	HashSet <String> hs = new HashSet <>();
    	//向集合中添加元素
    	hs.add("北京");
    	//添加重复元素
    	hs.add("北京");
    	hs.add("上海");
    	hs.add("天津");
    	hs.add("济南");
    	hs.add("青岛");
    	System.out.println(hs);//以数组形式输出
    	//使用foreach语句遍历
    	System.out.println("使用foreach语句遍历");
    	for(String e:hs){
    		System.out.println(e);
    	}
    	System.out.println("---------------------");
    	
    	//删除元素
    	hs.remove("青岛");
    	System.out.println("删除后剩下的数据:");
    	Iterator <String> iterator = hs.iterator();
    	//使用迭代器遍历
    	while(iterator.hasNext()){
    		System.out.println(iterator.next());
    	}
        }
    }
    
    

    运行结果:
    在这里插入图片描述
    结果中北京并没有出现在第一位,且仅出现了一次,证明了Set集合无法记住添加的顺序,Set集合中的元素不能重复的特点。

    4.Queue 接口及其实现类

    Queue接口:以“先进先出(FIFO)”的方式排序各个元素。
    Deque(双端队列)是Queue的子接口,LinkedList是Deque和List两个接口的实现类,兼具队列和列表两种特性,是最常使用的集合类之一。

    LinkedListDemo.java:

    import java.util.LinkedList;
    public class LinkedListDemo{
        public static void main(String[] args){
    	LinkedList <String> books = new LinkedList <>();
    	//在队尾添加元素
    	books.offer("Java Web开发技术详解");
    	//在队头添加元素
    	books.push("数据库原理");
    	//在队头添加元素
    	books.offerFirst("Java8基础应用与开发");
    	//在队尾添加元素
    	books.offerLast("C++程序设计");
    	System.out.println(books);
    	System.out.println("---------------------");
    	//使用foreach语句遍历
    	System.out.println("使用foreach语句遍历:");
    	for(String e:books){
    		System.out.println(e);
    	}	
        }
    }
    
    

    运行结果:
    在这里插入图片描述
    注意:经检验知push与offerFirst等价,都可以实现将数据插入开头;offer与offerLast等价,都是将数据插入末尾。

    5.Map 接口及其实现类

    Map接口:以key-value键值对映射关系存储的集合,可以根据每个元素的key来访问对应的value,Map集合中的key不允许重复,value可以重复。key-value键值对映射关系的示意图如下所示。

    在这里插入图片描述

    Map接口的两个实现类:
    HashMap:基于哈希算法的Map接口的实现类,该实现类提供所有映射操作,并允许使用null键和null值,但不能保证映射的顺序,即是无序的映射集合
    TreeMap:基于“树”接口来存储的Map接口实现类,可以根据键的自然顺序进行排序,或定制排序方式。在使用TreeMap时,不允许使用null键和null值,当使用get()方法获取元素时,没有指定的键时会返回null。

    在这里插入图片描述
    在这里插入图片描述
    HashMapDemo.java:

    import java.util.HashMap;
    public class HashMapDemo{
        public static void main(String[] args){
    	HashMap <Integer,String> hm = new HashMap <>();
    	//添加数据,key-value键值对形式
    	hm.put(1,"张三");
    	hm.put(2,"李四");
    	hm.put(3,"王二麻子");
    	hm.put(4,"赵五");
    	hm.put(5,"刘六");
    	hm.put(null,null);
    	//根据key值获取value
    	System.out.println(hm.get(1));
    	System.out.println(hm.get(3));
    	System.out.println(hm.get(5));
    	System.out.println(hm.get(null));
    
    	//根据key删除
    	hm.remove(1);
    
    	//key为1的元素已经删除,返回null
    	System.out.println(hm.get(1));	
        }
    }
    
    

    TreeMapDemo.java:

    import java.util.TreeMap;
    public class TreeMapDemo{
        public static void main(String[] args){
    	TreeMap <Integer,String> tm = new TreeMap <>();
    	//添加数据,key-value键值对形式
    	tm.put(1,"张三");
    	tm.put(2,"李四");
    	tm.put(3,"王二麻子");
    	tm.put(4,"赵五");
    	tm.put(5,"刘六");
    	//错误,不允许null键和null值
    	//tm.put(null,null);
    	//根据key值获取value
    	System.out.println(tm.get(1));
    	System.out.println(tm.get(3));
    	System.out.println(tm.get(5));
    	//错误,不允许null键和null值
    	//System.out.println(tm.get(null));
    
    	//根据key删除
    	tm.remove(1);
    
    	//key为1的元素已经删除,返回null
    	System.out.println(tm.get(1));	
        }
    }
    
    

    四、集合转换(了解)

    Map集合可以转换为Collection集合,方法:
    entrySet():返回一个包含了Map中元素的集合,每个元素都包括键和值。
    keySet():返回Map中所有键的集合。
    values():返回Map中所有值的集合。

    MapChangeCollectionDemo.java:

    import java.util.*;
    import java.util.Map.Entry;
    public class MapChangeCollectionDemo{
        public static void main(String[] args){
    	HashMap <Integer,String> hm = new HashMap <>();
    	//添加数据,key-value键值对形式
    	hm.put(1,"张三");
    	hm.put(2,"李四");
    	hm.put(3,"王二麻子");
    	hm.put(4,"赵五");
    	hm.put(5,"刘六");
    	//使用entrySet()方法获取Entry键值对集合,Map.Entry是Map声明的一个内部接口,此接口为泛型,定义为Entry。它表示Map中的一个实体(一个key-value对)。接口中有getKey(),getValue方法。
    	Set<Entry <Integer,String>> set = hm.entrySet();
    	System.out.println("所有Entry:");
    	//遍历所有元素
    	for(Entry <Integer,String> entry:set){
    		System.out.println(entry.getKey()+":"+entry.getValue());
    	}
    	System.out.println("-----------------");
    
    	//使用keySet()方法获取所有键的集合
    	Set <Integer> keySet = hm.keySet();
    	System.out.println("所有key:");
    	for(Integer key:keySet){
    		System.out.println(key);
    	}
    	System.out.println("-----------------");
    
    	//使用values()方法获取所有值的集合
    	Collection <String> valueSet = hm.values();
    	System.out.println("所有value:");
    	for(String value:valueSet){
    		System.out.println(value);
    	}
    
        }
    }
    
    

    五、集合工具类(了解)后期扩展

    Java集合框架汇总还提供了两个辅助工具类:Collections和Arrays。
    Collections工具类:提供了一些对Collection集合常用的静态方法,如排序、复制、查找以及填充等操作。
    Arrays工具类:提供了针对数组的各种静态方法,如排序、复制、查找等操作。


    总结

    本章重点掌握前三个知识点,泛型是将数据类型参数化,提高了代码的重用性。集合类分别讲了Collection接口下的三个常用子接口:List=>ArrarList(下标从0开始,可重复);Set=>HashSet(HashSet使用Hash算法来存储集合中的元素,具有良好的存、取以及可查找性,无序不可重复);Queue=>LinkedList(先进先出队列,push=offerFirst,offer=offerLast)。Map接口:Map=>HashMap(有键值对,key值不可以重复,value值可以重复,无序,键值对可以为null)。

    展开全文
  • Java泛型集合源代码

    2018-09-05 09:20:25
    图书《Java泛型集合》配套的完整的源代码资料,配合图书使用
  • Java 语言程序设计 C 实验报告 集合框架及泛型机制 学 生 姓 名 专 业 班 级 指 导 教 师 成 绩 计算机信息工程学院 年 月 日 . . 一实验目的 学习课程相关章节知识通过上机练习掌握以下知识 1掌握 List 接口下 ...
  • Java泛型集合]-英文版
  • Java实验报告(十)|泛型与集合

    千次阅读 2020-12-20 20:56:54
    (一)自定义泛型类MyStack,模拟数据结构中的“栈”,并测试。该类中至少包含以下方法: (1)压栈的方法push()。 (2)弹栈的方法pop()。 (3)获取栈顶元素的方法peek()。 (4)获取栈中元素的个数的方法size()。...

    题目一

    (一)自定义泛型类MyStack,模拟数据结构中的“栈”,并测试。该类中至少包含以下方法:
    (1)压栈的方法push()。
    (2)弹栈的方法pop()。
    (3)获取栈顶元素的方法peek()。
    (4)获取栈中元素的个数的方法size()。
    源程序:

    import java.util.ArrayList;
    
    public class TestStack {
        public static void main(String[] args) {
            MyStack<String> ms = new MyStack<>();
            ms.push("张三");
            ms.push("李四");
            ms.push("王五");
            ms.push("赵六");
            System.out.println("栈顶元素:"+ms.peek());
            System.out.println("栈空间大小:"+ms.getSize());
            ms.pop();
            ms.pop();
            System.out.println("栈顶元素:"+ms.peek());
            System.out.println("栈空间大小:"+ms.getSize());
        }
    
    }
    
    class MyStack<T> {
        ArrayList<T> arr = new ArrayList<>();
    
        //压栈的方法push()
        public void push(T data) {
            arr.add(data);
        }
    
        //弹栈的方法pop()
        public void pop() {
            arr.remove(arr.size() - 1);
        }
    
        //获取栈顶元素的方法peek()
        public T peek() {
            T data = arr.get(arr.size() - 1);
            return data;
        }
    
        //获取栈中元素的个数的方法size()
        public int getSize() {
            return arr.size();
        }
    }
    
    

    测试结果截图:
    在这里插入图片描述

    题目二

    (二)有下面的ArrayList,并使用foreach和迭代器遍历此链表。
    在这里插入图片描述
    使用foreach遍历链表的源程序:

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.Vector;
    
    public class Test02 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("java");
            list.add("python");
            list.add("c");
            list.add("c++");
            list.add("php");
            list.add("oc");
            //方法一 foreach
            for (String str : list
            ) {
                System.out.print(str + " ");
            }
        }
    }
    
    

    运行结果截图:
    在这里插入图片描述
    使用迭代器遍历链表的源程序:

    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.Vector;
    
    public class Test02 {
        public static void main(String[] args) {
            ArrayList<String> list = new ArrayList<>();
            list.add("java");
            list.add("python");
            list.add("c");
            list.add("c++");
            list.add("php");
            list.add("oc");     
            //方法二 迭代器
            System.out.println();
            Iterator<String> it = list.iterator();
            while (it.hasNext()){
                System.out.print(it.next()+" ");
            }
        }
    }
    

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

    题目三

    (三)有下面的Map集合,使用两种方法遍历。
    Map:
    在这里插入图片描述
    方法一源程序:

    import java.util.Set;
    import java.util.TreeMap;
    
    public class Test03 {
        public static void main(String[] args) {
    
            TreeMap<Integer, String> map = new TreeMap<>();
            map.put(1, "Java");
            map.put(2, "Python");
            map.put(3, "C");
            map.put(4, "C++");
            map.put(5, "PHP");
            //方法一 keySet()
            Set<Integer> keys = map.keySet();
            for (Integer key : keys
            ) {
                System.out.println(key+":" +map.get(key));
            }
        }
    }
    
    

    运行结果截图:
    在这里插入图片描述
    方法二源程序:

    import java.util.Map;
    import java.util.Set;
    import java.util.TreeMap;
    
    public class Test03 {
        public static void main(String[] args) {
    
            TreeMap<Integer, String> map = new TreeMap<>();
            map.put(1, "Java");
            map.put(2, "Python");
            map.put(3, "C");
            map.put(4, "C++");
            map.put(5, "PHP");
            //方法二: entrySet()
            Set<Map.Entry<Integer, String>> entries = map.entrySet();
            for (Map.Entry<Integer, String> entry : entries){
                System.out.println(entry.getKey() + ":" + entry.getValue());
            }
        }
    }
    
    

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

    题目四

    (四)双色球共有49个数字。其中红色球33个(数字从1-33),篮色球16个(数字从1-16)。编写一个程序,实现自动选号,每次选出一组号码(6个红色球和1个蓝色球)。
    源程序:

    import java.util.HashSet;
    import java.util.Random;
    import java.util.Set;
    
    public class Test04 {
        public static Set<Integer> getNums(int n, int count) {
            HashSet<Integer> nums = new HashSet<>();
            Random r = new Random();
            while (true) {
                nums.add(r.nextInt(n) + 1);
                if (nums.size() == count) {
                    break;
                }
            }
            return nums;
        }
    
        public static void main(String[] args) {
            System.out.println("红色球"+getNums(32,6));
            System.out.println("蓝色球"+getNums(32,6));
            System.out.println("绿色球"+getNums(32,6));
        }
    }
    
    

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

    收获:
    1、 泛型、学会自定义泛型的定义以及应用。
    2、通过arraylist模拟栈这种先进后出的数据结构,实现pop(),push(),peek(),getSize()等方法,并进行测试。
    3、学会使用foreach和vector迭代器迭代输出数组中的元素。
    4、泛型的好处1.类型安全2.能够避免在强转时出现问题
    5、学会使用map里的keySet()和entrySet()方法。
    6、了解掌握HashSet以及TreeSet的相关属性及其方法。

    展开全文
  • Java泛型集合

    2021-06-05 17:26:01
    泛型集合 概念:参数化类型,类型安全的集合,强制集合元素的类型必须一致 特点: ​ 编译时即可检查,而非运行时抛出异常 ​ 访问时,不必类型转换(拆箱) ​ 不同泛型之间引用不能相互赋值,泛型不存在多态 ...
  • 泛型集合

    2021-04-24 12:34:47
    有一个小误点: 二分查找 在计算机科学中,二分搜索(英语:binary search),也称折半搜索(英语:half-... } } 编译运行: $ javac BinarySearch.java $ java BinarySearch 4 本代码中如果查询为1,则返回的为-1
  • Java实验之泛型与集合框架

    千次阅读 热门讨论 2021-01-04 17:26:35
    Java实验之泛型与集合框架 搭建流水线 实验要求 程序有时候需要将任务按流水式进行,例如评判体操选手的任务按流水式为依次的三个步骤:录入裁判给选手的分数,去掉一个最高分和最低分,计算出平均成绩,编写程序,...
  • 找了好久都只有Java泛型与集合这本书的chm版本,现在终于找到了pdf版本,分享一下
  • 集合容器类在设计阶段/声明阶段不能确定这个容器到底实际存的是什么类型的对象,所以在JDK1.5之前只能把元素类型设计为Object,JDK1.5之后使用泛型来解决。因为这个时候除了元素的类型不确定,其他的部分
  • JAVA泛型集合

    2018-04-26 14:01:18
    java 泛型 集合java 泛型 集合java 泛型 集合java 泛型 集合
  • 本次实验掌握了集合的概念、体系结构、分类及使用场景,了解了Set接口及主要实现类(HashSet、TreeSet),了解了解List接口及主要实现类(ArrayList、LinkedList、Vector),掌握ArrayList的使用及其Vector的区别,...
  • Java泛型单元试题.html

    2020-03-17 21:15:36
    精选java关于泛型的原理,应用和面试题,包含所有泛型考点。例如,泛型的概念,类型,实例化,容易混淆的用法。每一道题附上答案,方便理解考试要点。
  • 泛型与集合 使用 进行初步翻译. 将利用碎片时间进行整理和校对,完整的时间段适合做其他需要大量思考的事,如果你有兴趣欢迎提交PR。 TODO 数据校对 目录 2.4 获取和放置原则 2.5 数组 2.6 通配符类型参数 2.7 ...
  • 03-Java集合-泛型面试题(24题)-新增
  • Java 1.5 之前没有泛型,通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型,这种转换要求开发者对实际参数的类型具有可预知性。对于强制类型转换错误的情况,编译器可能不会提示错误,但是在...
  • 我得到的是接口不使用ArrayList的任何泛型类型参数(即ArrayList),但是接口方法的实现者(即ArrayList).其他实现者可以使用任何其他类型参数返回ArrayLists,不是吗? 所以我的问题:这是一个问题吗?我应该重构一下吗...
  • JAVA泛型是jdk1.5引入的一个新特性,本质是参数化类型,把类型作为参数传递 常见的有:泛型类、泛型接口、泛型方法 语法:<T,...>T表示类型占位符,表示一种应用类型 好处1、提高代码重用。2、防止类型转换...
  • Java 集合与泛型示例 Github 路径 作者 目录 LICENSE
  • 这周学习了Java课程中的集合体系和泛型,以及字符串的应用,这周的任务真的繁重啊,有好多自己屡不清楚的地方,所以周末要好好练习,泛型,就是指参数化数据,就是将类型由原来的具体的类型参数化,泛型的本质是为了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 128,593
精华内容 51,437
关键字:

java 泛型与集合

java 订阅