精华内容
下载资源
问答
  • 在集合中使用泛型

    2020-08-12 22:33:03
    在集合中使用泛型 package com.atguigu.java; import org.junit.Test; import java.util.*; /** * * 泛型的使用 * 1.jdk 5.0新增的特性 * * 2.在集合中使用泛型: * 总结: * ① 集合接口或集合类在jdk5.0...

    在集合中使用泛型

    package com.atguigu.java;
    
    import org.junit.Test;
    
    import java.util.*;
    
    /**
     *
     * 泛型的使用
     * 1.jdk 5.0新增的特性
     *
     * 2.在集合中使用泛型:
     *  总结:
     *  ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
     *  ② 在实例化集合类时,可以指明具体的泛型类型
     *  ③ 指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。
     *    比如:add(E e)  --->实例化以后:add(Integer e)
     *  ④ 注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换
     *  ⑤ 如果实例化时,没有指明泛型的类型。默认类型为java.lang.Object类型。
     *
     * 3.如何自定义泛型结构:泛型类、泛型接口;泛型方法。见 GenericTest1.java
     *
     * @author shkstart
     * @create 2019 上午 9:59
     */
    public class GenericTest {
    
    
        //在集合中使用泛型之前的情况:
        @Test
        public void test1(){
            ArrayList list = new ArrayList();
            //需求:存放学生的成绩
            list.add(78);
            list.add(76);
            list.add(89);
            list.add(88);
            //问题一:类型不安全
    //        list.add("Tom");
    
            for(Object score : list){
                //问题二:强转时,可能出现ClassCastException
                int stuScore = (Integer) score;
    
                System.out.println(stuScore);
    
            }
    
        }
    
        //在集合中使用泛型的情况:以ArrayList为例
        @Test
        public void test2(){
           ArrayList<Integer> list =  new ArrayList<Integer>();
    
            list.add(78);
            list.add(87);
            list.add(99);
            list.add(65);
            //编译时,就会进行类型检查,保证数据的安全
    //        list.add("Tom");
    
            //方式一:
    //        for(Integer score : list){
    //            //避免了强转操作
    //            int stuScore = score;
    //
    //            System.out.println(stuScore);
    //
    //        }
            //方式二:
            Iterator<Integer> iterator = list.iterator();
            while(iterator.hasNext()){
                int stuScore = iterator.next();
                System.out.println(stuScore);
            }
    
        }
    
        //在集合中使用泛型的情况:以HashMap为例
        @Test
        public void test3(){
    //        Map<String,Integer> map = new HashMap<String,Integer>();
            //jdk7新特性:类型推断
            Map<String,Integer> map = new HashMap<>();
    
            map.put("Tom",87);
            map.put("Jerry",87);
            map.put("Jack",67);
    
    //        map.put(123,"ABC");
            //泛型的嵌套
            Set<Map.Entry<String,Integer>> entry = map.entrySet();
            Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    
            while(iterator.hasNext()){
                Map.Entry<String, Integer> e = iterator.next();
                String key = e.getKey();
                Integer value = e.getValue();
                System.out.println(key + "----" + value);
            }
    
        }
    
    
    }
    
    
    展开全文
  • 在集合中使用泛型的场景   //2.在集合中使用泛型的场景 @Test public void test2() { //1.List使用泛型 List&lt;Integer&gt; list = new ArrayList&lt;Integer&gt;(); list.add(75); ...

    在集合中使用泛型的场景

     

    //2.在集合中使用泛型的场景
    @Test
    public void test2() {
    	
    	//1.List使用泛型
    	List<Integer> list = new ArrayList<Integer>();
    	list.add(75);
    	list.add(85);
    	list.add(95);
    	//list.add("AA"); 会报编译错误,只能添加Integer类型数据
    	//第1种遍历List的方式
    	for(int i=0; i<list.size(); i++) {
    		int score = list.get(i);
    		//输出:75 85 95
    		System.out.print(score + " ");
    	}
    	//第2种遍历List的方式
    	Iterator<Integer> iter = list.iterator();
    	while(iter.hasNext()) {
    		int score = iter.next();
    		//输出:75 85 95
    		System.out.print(score + " ");
    	}
    	
    	//2.Map使用泛型
    	Map<String,Integer> map = new HashMap<String,Integer>();
    	map.put("AA", 75);
    	map.put("BB", 85);
    	map.put("CC", 95);
    	//遍历Map中的数据
    	Set<Entry<String,Integer>> set = map.entrySet();
    	for(Entry<String,Integer> entry:set) {
    		String key = entry.getKey();
    		int value = entry.getValue();
    		//输出:AA===75
    		//    BB===85
    		//	  CC===95
    		System.out.println(key + "===" + value);
    	}
    }

     

     

     

     

    展开全文
  • 12-1 泛型 ---- 在集合中使用泛型 总结: 1.集合接口或集合类在jdk5.0时都修改为带泛型的结构。 2.在实例化集合类时,可以指明具体的泛型类型 3.指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:...

    12-2 泛型 ---- 在集合中使用泛型

    总结:
    1.集合接口或集合类在jdk5.0时都修改为带泛型的结构。
    2.在实例化集合类时,可以指明具体的泛型类型
    3.指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。
    比如:add(E e) —>实例化以后:add(Integer e)
    4.注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换
    5.如果实例化时,没有指明泛型的类型。默认类型为java.lang.Object类型。

    代码:

    package java1;
    
    import org.junit.Test;
    
    import java.util.*;
    
    public class GenericTest1 {
        //在集合中使用泛型的情况
        @Test
        public void test1() {
            ArrayList<Integer> list = new ArrayList<Integer>();
    
            list.add(77);
            list.add(86);
            list.add(99);
            list.add(60);
            list.add(43);
    
            //编译时,就会进行类型检查,保证数据的安全
    //        list.add("Tom");
    
            //方式一:
    //        for(Integer score : list){
    //            //避免了强转操作
    //            int stuScore = score;
    //            System.out.println(stuScore);
    //        }
    
            //方式二:
            Iterator<Integer> iterator = list.iterator();
            while (iterator.hasNext()) {
                int stuScore = iterator.next();
                System.out.println(stuScore);
            }
        }
    
        //在集合中使用泛型的情况:以HashMap为例
        @Test
        public void test2() {
            HashMap<String, Integer> map = new HashMap<>();
    
            map.put("Tom", 99);
            map.put("asd", 86);
            map.put("Tert", 45);
            map.put("xcv", 33);
    //        map.put(123,"Abd");
    
            //泛型测嵌套
            Set<Map.Entry<String, Integer>> entry = map.entrySet();
            Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
    
            while (iterator.hasNext()) {
                Map.Entry<String, Integer> e = iterator.next();
                String key = e.getKey();
                Integer value = e.getValue();
                System.out.println("key = " + key + ", value = " + value);
            }
    
            
        }
    
    }
    
    

    test1输出:

    77
    86
    99
    60
    43
    

    test2输出:

    key = Tom, value = 99
    key = asd, value = 86
    key = Tert, value = 45
    key = xcv, value = 33
    
    展开全文
  • 那么为什么要有泛型呢,直接Object不是也可以存储...在集合中使用泛型 ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。 ② 在实例化集合类时,可以指明具体的泛型类型 ③ 指明完以后,在集合类或接口中凡是定义类

    那么为什么要有泛型呢,直接Object不是也可以存储数据?

    1.解决元素存储的安全性问题,好比商品、药品标签,不会弄错。

    2.解决获取数据元素时,需要类型强制转换的问题,好比不用每回拿商品、药品都要辨别。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SkaNah3u-1614527998965)(D:\笔记图片\2021\1月\2021年2月27日没有泛型.png)]

    Java泛型可以保证如果程序在编译时没有发出警告,运行时就不会产生ClassCastException异常。同时,代码更加简洁、健壮。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vRpVpXIA-1614527998967)(D:\笔记图片\2021\1月\2021年2月27日有泛型.png)]

    在集合中使用泛型

    ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。

    ② 在实例化集合类时,可以指明具体的泛型类型

    ③ 指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。

    • 比如:add(E e) —>实例化以后:add(Integer e)

    ④ 注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换

    ⑤ 如果实例化时,没指明泛型的类型。默认类型为java.lang.Object类型。

    import org.junit.Test;
    import java.util.*;
    /*
    集合中使用泛型总结:
    
    *  ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。
    *  ② 在实例化集合类时,可以指明具体的泛型类型
    *  ③ 指明完以后,在集合类或接口中凡是定义类或接口时,内部结构(比如:方法、构造器、属性等)使用到类的泛型的位置,都指定为实例化的泛型类型。
    *    比如:add(E e)  --->实例化以后:add(Integer e)
    *  ④ 注意点:泛型的类型必须是类,不能是基本数据类型。需要用到基本数据类型的位置,拿包装类替换
    *  ⑤ 如果实例化时,没指明泛型的类型。默认类型为java.lang.Object类型。
     */
    public class GenericTest {
        //在集合中使用泛型之前的情况:
        @Test
        public void test1(){
            ArrayList list = new ArrayList();
            //需求:存放学生成绩
            list.add(00);
            list.add(68);
            list.add(97);
            list.add(96);
            //问题一,类型不安全
            list.add("Tom");
    
            for(Object score : list){
                //问题二,强转时,可能出现ClassCastException
                int stuScore = (Integer) score;
                System.out.println(stuScore);
            }
        }
        //在集合中使用泛型的情况:以ArrayList举例
        @Test
        public void test2(){
            ArrayList<Integer> list = new ArrayList<Integer>();
            list.add(78);
            list.add(98);
            list.add(69);
            list.add(78);
            //编译时就会数据检查,保证数据的安全
            //方式一:
            for(Integer integer : list){
                //避免了强转操作
                System.out.println(integer);
            }
            Iterator<Integer> iterator = list.iterator();
            while(iterator.hasNext()){
                int stuScore = iterator.next();
                System.out.println(stuScore);
            }
        }
        //在集合中使用泛型的情况:以HashMap举例
        @Test
        public void test3(){
            Map<String, Integer> map = new HashMap<>();
            map.put("Tom",88);
            map.put("Jerry",82);
            map.put("Jack",72);
            Set<Map.Entry<String,Integer>> entry = map.entrySet();
            Iterator<Map.Entry<String, Integer>> iterator = entry.iterator();
            while(iterator.hasNext()){
                Map.Entry<String, Integer> e = iterator.next();
                String key = e.getKey();
                int i = e.getValue();
                System.out.println(key + "-->" + i);
            }
        }
    }
    

    自定义泛型结构

    1.泛型的声明

    interface List 和class GenTest<K,V>

    其中,T,K,V不代表值,而是表示类型。这里使用任意字母都可以。

    常用T表示,是Type的缩写。

    2.泛型的实例化:

    一定要在类名后面指定类型参数的值(类型)。如:

    List strList= new ArrayList();

    Iterator iterator = customers.iterator();

    • T只能是类,不能用基本数据类型填充。但可以使用包装类填充

    • 把一个集合中的内容限制为一个特定的数据类型,这就是generics背后的核心思想

    自定义泛型结构:泛型类、泛型接口

    1,泛型类可能有多个参数,此时应将多个参数一起放在尖括号内。比如:<E1,E2,E3>

    2,泛型类的构造器如下:public GenericClass(){}。

    而下面是错误的:public GenericClass(){}

    3,实例化后,操作原来泛型位置的结构必须与指定的泛型类型一致。

    4,泛型不同的引用不能相互赋值。

    尽管在编译时ArrayList和ArrayList是两种类型,但是,在运行时只有一个ArrayList被加载到JVM中。

    5,泛型如果不指定,将被擦除,泛型对应的类型均按照Object处理,但不等价于Object。经验:泛型要使用一路都用。要不用,一路都不要用。

    6,如果泛型结构是一个接口或抽象类,则不可创建泛型类的对象。

    7,jdk1.7,泛型的简化操作:ArrayList flist = new ArrayList<>();

    8,泛型的指定中不能使用基本数据类型,可以使用包装类替换。

    9,在类/接口上声明的泛型,在本类或本接口中即代表某种类型,可以作为非静态属性的类型、非静态方法的参数类型、非静态方法的返回值类型。但在静态方法中不能使用类的泛型。

    10, 异常类不能是泛型的

    11, 不能使用new E[]。但是可以:E[] elements = (E[])new Object[capacity];

    参考:ArrayList源码中声明:Object[] elementData,而非泛型参数类型数组。

    12,父类有泛型,子类可以选择保留泛型也可以选择指定泛型类型:

    子类不保留父类的泛型:按需实现

    • 没有类型擦除

    • 具体类型

    子类保留父类的泛型:泛型子类

    • 全部保留

    • 部分保留

    结论:子类必须是“富二代”,子类除了指定或保留父类的泛型,还可以增加自己的泛型

    class Father<T1, T2> {
    }
    // 子类不保留父类的泛型
    // 1)没有类型擦除
    class Son1 extends Father {// 等价于class Son extends Father<Object,Object>{
    }
    // 2)具体类型
    class Son2 extends Father<Integer, String> {
    }
    // 子类保留父类的泛型
    // 1)全部保留
    class Son3<T1, T2> extends Father<T1, T2> {
    }
    // 2)部分保留
    class Son4<T2> extends Father<Integer, T2> {
    }
    class Father<T1, T2> {
    }
    // 子类不保留父类的泛型
    // 1)没有类型擦除
    class Son<A, B> extends Father{//等价于class Son extends Father<Object,Object>{
    }
    // 2)具体类型
    class Son2<A, B> extends Father<Integer, String> {
    }
    // 子类保留父类的泛型
    // 1)全部保留
    class Son3<T1, T2, A, B> extends Father<T1, T2> {
    }
    // 2)部分保留
    class Son4<T2, A, B> extends Father<Integer, T2> {
    }
    
    class Person<T> {
    // 使用T类型定义变量
    private T info;
    // 使用T类型定义一般方法
    public T getInfo() {
    return info;
    }
    public void setInfo(T info) {
    this.info= info;
    }
    // 使用T类型定义构造器
    public Person() {
    }
    public Person(T info) {
    this.info= info;
    }
    
    // static的方法中不能声明泛型
    //public static void show(T t) {
    //
    //}
    // 不能在try-catch中使用泛型定义
    //public void test() {
    //try {
    //
    //} catch (MyException<T> ex) {
    //
    //		}
    //	}
    
    展开全文
  • 我们编写程序时,经常遇到两个模块的功能非常相似,只是一个是处理int类型数据,另一个处理...为什么要使用泛型为了了解这个问题,我们先看下面的代码,代码省略了一些内容,但功能是实现一个栈,这个栈只能出来in...
  • 泛型 泛型的概念: 所谓泛型,就是允许定义类、接口时通过一个标识表示类某个属性的类 型或者是某个方法的返回值及参数类型。...使用泛型的主要优点是能够编译时而不是运行时检测错误
  • 泛型泛型1 为什么要有泛型2 在集合中使用泛型3 自定义泛型3.1 泛型类、泛型接口3.2 泛型方法4 泛型在继承上的体现5 通配符的使用5.1 使用5.2 使用注意点5.3 有限制的通配符5.3.1 简述5.3.2 练习题6 泛型应用举例7 ...
  • 泛型(一)集合中使用泛型

    千次阅读 2016-05-23 16:24:20
    1.在集合中使用泛型 2.自定义泛型类、泛型接口、泛型方法 3.泛型与继承的关系 4.通配符 若类A是类B的子类,那么List就不是List的子接口 通配符? 都是?的子类 例如 booleancontainsAll(Collection c); ...
  • 泛型的作用 泛型:类似于标签标签 集合容器类在设计阶段/声明阶段不能确定这个容器是用来装什么类型的对象,所以在jdk1.5之前只能把元素类型设计为Object,在jdk1.5之后...在集合中使用泛型时: package www.bh
  • 集合类型后面会有<E>,如:Collection<E>、List<E>、AeeayList<E>、Set<E>、Map<E>。 尖括号的E、K、V等是类型参数名称,他们是实际类型的占位符。 代码示例 import java....
  • Java-什么是泛型,为什么使用泛型集合中的泛型使用,自定义泛型类,泛型方法,泛型的使用场景,泛型继承方面的体现,无边界通配符,上界通配符,下界通配符,泛型的约束与局限性
  • 在集合中没有使用泛型的场景   //1.在集合中没有使用泛型的场景 @Test public void test1() { //添加数据到集合中 List list = new ArrayList(); list.add(75); list.add(85); list.add(95); //1....
  • -----------------------java集合中的泛型的使用------------------------我们在项目中使用集合基本99%都是在集合中存储同一种数据类型。既然我们在集合中存储同一种数据类型,我们事先一定知道这个集合中要存储什么...
  • 集合中泛型

    2018-04-26 23:28:57
    泛型泛型:是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。...​集合中泛型的使用创建集合使用泛型指定集合只能存放的数据类型。(把运行时期的问题提前到了编译期间)遍历集合...
  • 什么是泛型? 泛型最常与集合使用,因为泛型最开始开始被加入Java就是为了解决集合向下转型一类问题的...List中使用泛型 我们创建集合时使用<>来声明List集合只能保存Dog类对象 List dogs=new ArrayList<>
  • 建议20:使用泛型集合代替非泛型集合 建议1我们知道,如果要让代码高效运行,应该尽量避免装箱和拆箱,以及尽量减少转型。很遗憾,微软提供给我们的第一代集合类型没有做到这一点,下面我们看ArrayList这...
  • packageatguigu.senior.day10.java...在集合中使用泛型:* 总结:* ① 集合接口或集合类在jdk5.0时都修改为带泛型的结构。* ② 在实例化集合类时,可以指明具体的泛型类型* ③ 指明完以后,在集合类或接口中凡是定义...
  • 不要小看这些技巧,一旦开发中使用了错误的集合或针对集合的方法,应用程序将会背离你的预想而运行。 建议20:使用泛型集合代替非泛型集合 建议1中我们知道,如果要让代码高效运行,应该尽量避免装箱和拆箱,...
  • Grizzly允许您GO中使用集合,而不用泛型。 使用Grizzly,您可以使用Map,过滤器,查找等方法。
  • 为什么在集合中使用泛型? 因为大多数情况下,我们只会在集合中存储同一类型的对象。 测试代码: import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class
  • 1. 在集合中使用泛型之前的例子@Testpublic void test1(){ArrayList list = new ArrayList();//需求:存放学生的成绩list.add(78);list.add(76);list.add(89);list.add(88);//问题一:类型不安全// list.add("Tom");...
  • C#中关于List集合中使用泛型的例子
  • C#中关于LinkedList集合中使用泛型的例子

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,558
精华内容 1,823
关键字:

在集合中使用泛型