V哥：泛型学习笔记

最新推荐文章于 2024-08-23 15:54:50 发布
最新推荐文章于 2024-08-23 15:54:50 发布
阅读量154 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/birchleafed/article/details/120117355
版权 

package com.genericity;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class GenericityTest {
    public static void main(String[] args) {
        List persons = new ArrayList();
        persons.add("hhh");
        persons.add("sss");
        persons.add("aaa");
        persons.add(19);
//        persons.forEach(new Consumer() {
//            @Override
//            public void accept(Object person) {
//                System.out.println(person);
//            }
//        });
        persons.forEach(person -> System.out.println(((String) person).length()));
    }
}


package com.genericity;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class GenericityTest {
    public static void main(String[] args) {
        List<String> persons = new ArrayList<String>();
        persons.add("hhh");
        persons.add("sss");
        persons.add("aaa");
     
        persons.forEach(person -> System.out.println(((String) person).length()));
    }
}

 

    Map<String,Integer> persons = new HashMap<String ,Integer>();
        persons.put("ssss",38);
        persons.put("aaaa",32);
        persons.put("vvvv",33);
        persons.put("zzzz",34);

        persons.forEach((key,value) -> System.out.println(key+"="+value));

 

 1、自定义泛型

Iterator对象定义泛型

 Map定义泛型

 我们可以看到，上面自定义泛型的时候，我们就是在类名的后面加上类型的替代符

比如T，K，V。我们在使用的时候直接把这些T，K，V，替换成对应的类型名称就好； 

package com.genericity;

public class MyDefineTest {
    private static class A<T>{
        private T info;

        public T getInfo() {
            return info;
        }

        public A(T info) {
            this.info = info;
        }

    }
    public static void main(String[] args) {
        A<String> a = new A<>("ssd");
        System.out.println(a.getInfo());
        A<Integer> a1 = new A<>(2);
        System.out.println(a1.getInfo());

    }
}

 

 下面代码不可以

    private static class B extends A<T>{
        public B(T info) {
            super(info);
        }
    }

可以用如下方式使用

package com.genericity;

public class MyDefineTest {
    private static class A<T>{
        private T info;

        public T getInfo() {
            return info;
        }

        public A(T info) {
            this.info = info;
        }

    }
    private static class B extends A<String >{
        public B(String info) {
            super(info);
        }
    }
    public static void main(String[] args) {
        B b = new B("sss");
        System.out.println(b.getInfo());

    }
}

但是，有时候，我们定义一个子类的时候，我们还是无法判断泛型的类型：

package com.genericity;

public class MyDefineTest {
    private static class A<T>{
        private T info;

        public T getInfo() {
            return info;
        }

        public A(T info) {
            this.info = info;
        }

    }
    private static class B<T> extends A<T >{
        public B(T info) {
            super(info);
        }
    }
    public static void main(String[] args) {

        B<String> b = new B<>("sss");
        System.out.println(b.getInfo());

    }
}

3、并不存在泛型类

package com.genericity;

public class MyDefineTest {
    private static class A<T>{
        private T info;

        public T getInfo() {
            return info;
        }

        public A(T info) {
            this.info = info;
        }

    }
    private static class B<T> extends A<T >{
        public B(T info) {
            super(info);
        }
    }
    public static void main(String[] args) {
        A<String> a1 = new A<>("sss");
        A<Integer> a2 = new A<>(33);
        System.out.println(a1.getClass());
        System.out.println(a2.getClass());
        System.out.println(a1.getClass().equals(a2.getClass()));

    }
}

运行出来我们发现a1.getClass()和a2.getClass()相等，那证明不存在泛型类

package com.genericity;

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

public class WildcsrdProblemTest {
    private static void test(List<Object> list){
        for (Object o :list){
            System.out.println(o);
        }
    }

    public static void main(String[] args) {
        List<String > persons = new ArrayList<>();
        persons.add("hhh");
        persons.add("zzz");
        persons.add("aaa");
        test(persons);
    }
}

 

 解决方案修改代码

package com.genericity;

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

public class WildcsrdProblemTest {
    private static void test(List<?> list){
        for (Object o :list){
            System.out.println(o);
        }
    }

    public static void main(String[] args) {
        List<String > persons = new ArrayList<>();
        persons.add("hhh");
        persons.add("zzz");
        persons.add("aaa");
        test(persons);
    }
}

上面的List<？>，其中的？表示的就是一个通配符，表示可以匹配任何类型。在使用的时候，通配符里面的元素，我们用object类型

package com.genericity;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class WildcardTest {

    private static class Animal{
        public void say(){
            System.out.println("I am animal i will speak");
        }
    }

    private static class Dog extends Animal{
        @Override
        public void say(){
            System.out.println("I am a dog wangwangwang !");
        }
    }

    private static class Cat extends Animal{
        @Override
        public void say(){
            System.out.println("I am a cat maoamoamao !");
        }
    }

    //List<? extends Animal>限制我们的List中的泛型必须是Animal或者是Animal 的子类
    private static void animalSay(List<? extends Animal> animals){
        animals.forEach(animal -> animal.say());
    }


    //如果在Apple<T extends Number>在下面的String类型的泛型使用时就会报错，extends 类 &接口
    private static class Apple<T extends Number & Serializable>{
        private T info;

        public Apple(T info) {
            this.info = info;
        }

        public T getInfo() {
            return info;
        }

        public void setInfo(T info) {
            this.info = info;
        }


    }

    public static void main(String[] args) {
        List<Animal> animals = new ArrayList<>();
        animals.add(new Dog());
        animals.add(new Cat());
        animalSay(animals);

        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        animalSay(dogs);

        List<Cat> cats = new ArrayList<>();
        cats.add(new Cat());
        animalSay(cats);
//
//        List<String> persons = new ArrayList<>();
//        persons.add("dadsada");
//        animalSay(persons);

       // Apple<String> apple = new Apple<>("I am an Apple");
        //System.out.println(apple.getInfo());

        Apple<Integer> apple1 = new Apple<>(49);
        System.out.println(apple1.getInfo());

    }


}


package com.genericity;


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

public class MethodTest {
    private static void arrayToList(Object[] objs, List<Object> list){
        for (Object obj : objs) {
            list.add(obj);
        }
    }

    public static void main(String[] args) {
        Object[] strArr = {"aaa","bbb","ccc"};
        List<String> list = new ArrayList<>();
        arrayToList(strArr,list);//报错
    }
}


package com.genericity;


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

public class MethodTest {
    private static <T> void arrayToList(T[] objs, List<T> list){
        for (T obj : objs) {
            list.add(obj);
        }
    }

    public static void main(String[] args) {
        String [] strArr = {"aaa","bbb","ccc"};
        List<String> list = new ArrayList<>();
        arrayToList(strArr,list);
        System.out.println(list);
    }
}


package com.genericity;


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

public class MethodTest {

    private static <T> void test(List<T> list1,List<T> list2){
        System.out.println(list1);
        System.out.println(list2);
    }

    public static void main(String[] args) {


        List<Object> list1 = new ArrayList<>();
        list1.add(1);
        list1.add(1);
        list1.add(1);
        list1.add(1);
        List<String> list2 = new ArrayList<>();
        list2.add("jljj");
        list2.add("jljj");
        list2.add("jljj");
        list2.add("jljj");
        list2.add("jljj");

        test(list1,list2);//类型不一样一个int一个String最后出现错误

    }
}

 还可以两个类型解决问题

 

package com.genericity;

public class GenterTest {
    private static class Foo{
        public <T> Foo(T t){
            System.out.println(t);
        }
    }

    public static void main(String[] args) {
        new Foo("dddd");//String类型数据
        new Foo(233);//Integer类型
        new <String> Foo("ads");//显示了传入的类型
        new <String> Foo(2323);//类型不匹配报错
    }
}


package com.genericity;

public class InferTest {
    public static class A<T>{
        public static <E> A<E> test1(){
            System.out.println("test1");
            return new A<>();
        }
        public static <E> A<E> test2(E e,A<E> a){
            System.out.println("test2");

            return new A<>();
        }
        public T head(){
            System.out.println("test3");

            return null;
        }
    }

    public static void main(String[] args) {

        //下面两行代码相同
        A<String> a1 = A.test1();//自动识别
        A<String> a2 = A.<String>test1();

        //下面两行相同
        A.test2(56,A.test1());
        A.test2(56,A.<Integer>test1());

    }
}


        //下面代码自动类型推断A.test1().head();两次推断最后就不能推断
        String a = A.<String>test1().head();

package com.genericity;

public class ErasureTest {
    private static class A<T extends Number>{
        private T size;

        public T getSize() {
            return size;
        }

        public A(T size) {
            this.size = size;
        }
    }

    public static void main(String[] args) {
        A<Integer> a = new A<>(50);
        int size = a.getSize();
        System.out.println(size);

        A a1 = a;
        int size1 = a1.getSize();
        System.out.println(size1);
    }
}

birchleafed
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
泛型+反射：泛型 笔记 ，课后作业
07-18
泛型+反射：泛型 笔记 ，课后作业
java基础学习笔记之泛型
09-02
泛型是Java编程语言中的一个重要特性，首次在JDK 1.5版本中引入，它允许程序员在定义类、接口和方法时使用类型参数，从而实现了类型的安全性和代码的复用性。泛型的主要目标是增强类型安全，避免在运行时出现...
浅聊一下Lambda表达式
Hubery_sky的博客
10-06 557
概念：Lambda表达式是JDK8的一个新特性,可以取代大部分的匿名内部类写出更优雅的Java代码，尤其在集合的遍历和其他集合操作中,可以极大地优化代码结构。
Java8 Lambda表达式教程
M_Jack的博客
02-18 228
1. 什么是λ表达式 λ表达式本质上是一个匿名方法。让我们来看下面这个例子： public int add(int x, int y) { return x + y; } 转成λ表达式后是这个样子： (int x, int y) -> x + y; 参数类型也可以省略，Java编译器会根据上下文推断出来： (x, y) -> x + y; //返回两数之和 或者 (x, y) -> { return x + y...
list 多种排序，java8 ，Lambda写法，升序降序，多条件排序
kanglong129的博客
11-25 7291
package com.xiong.test.group_sort; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.List; /** * @author Tan * @version V1.0 * @descriptio...
guava之Ordering的使用实例
请叫我大师兄
08-30 1307
guava的ordering这个类的使用，帮助代码排序。很不错的。 1，先是简单的排序使用。 /** * 默认的排序器 * natural() 对可排序类型做自然排序，如数字按大小，日期按先后排序 * reverse() 对当前的比较器进行反转 * 自然排序，不能将汉字按首字母的顺序排序。 */ private static ...
List集合方法总结
Lzfnemo2009的博客
10-10 1182
List
详解：泛型、擦除、边界
12-21
2. 多参数泛型：在`Tested`类的另一个版本中，我们看到可以同时指定多个类型参数，如`Tested, B>`，这样类就可以持有两种不同类型的对象。通过这种方式，我们可以创建更加灵活的类结构，以适应不同的数据组合需求。 ...
thinkingInJava15:泛型
06-29
"Thinking in Java"是一本经典的Java学习书籍，其第15章深入探讨了泛型的各个方面。在"thinkingInJava15-master"这个压缩包文件中，很可能包含了与泛型相关的源代码示例和讲解。 1. **泛型的基本概念**： 泛型是在...
Java基础篇：泛型.pdf
04-24
在定义泛型类或接口时，可以使用类型参数（如T、K和V）来表示类中某些属性的类型或方法的返回值及参数类型。类型参数在使用时才被具体化，即在创建对象或声明变量时传入实际的类型实参。 泛型类可以有多个类型参数...
深入理解 - java泛型
weixin_33766168的博客
02-19 62
泛型：字面意思可理解为广泛得、泛泛地类型，不具体指定为某一种类型；在使用上，则可以理解为类型参数，将类型当做参数传递给一个类、接口或者方法 泛型在哪里使用？ 泛型可使用在类、接口以及方法。 泛型在类中使用 示例如下： public class GenericClass<T>{ private T data; public GenericClass(T data) ...
java中foreach三种遍历方法
Amory的博客
11-16 2168
foreach遍历的方法 方法一： for(User u : user){ System.out.println(u); } 方法二： user.foreach(System.out::println) 方法三： user.foreach(u -> System,out.println(u));
java基础（泛型小结）
weixin_44226752的博客
07-23 327
泛型是什么 泛型是java5的新特性，它是类和接口的扩展，它是带一个或者多个类型参数的类和接口。类型参数中的类型可以是接口或者类，但不能是基本数据类型。 设计原则：只要在编译时期没有出现错误，那么运行时期就不会出现ClassCastException异常。 泛型：它把类型明确的工作推迟到创建对象或调用方法时才去明确的特殊的类型 参数化类型：把类型当做参数来传递，<>中只能是引用类型 为什么要引入泛型 因为Object类是所有类的父类，所以java早期是使用object来代表任意类型的，但是
2020.8.6泛型
weixin_46669997的博客
08-06 106
01_泛型 定义：是一种把类型明确的工作 作用推迟创建对象，或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递 泛型的格式: <数据类型> 这里的数据类型只能是引用数据类型 泛型好处： 把运行时期的问题提前到了编译期间 避免了强制类型转换 优化了程序设计，解决了黄色警告线 案例演示：引出泛型 package GenericDemo01; import java.util.ArrayList; //ArrayList存储字符串并遍历泛型版 public class G
关于java中的foreach遍历方式
Theodore__zz的博客
05-05 2537
关于java中的foreach遍历方式 foreach使用方式为： for(String s : strings){ //... } 其中的s是对strings中的迭代对象的引用，即对s进行任何赋值操作并不会改变strings中元素的内容，即： String[] nameStrings = "C:\\Users\\LJY\\Desktop".split("\\\\"); for(Strin...
泛型的Foreach方法与foreach语句的区别
在路上
07-14 3557
泛型的Foreach方法与foreach语句的区别?  List lst=new List();  lst.ForEach(delegate(Person p)  {  p = null;//不会报错，但不会改变对象的值  p = new item();//不会报错，但不会改变对
foreach的用法
02-08 159
val m = Map[String, Int]("a" -> 1, "b" -> 2, "c" -> 3) m.foreach(p => println("key=" + p._1 + ", value=" + p._2))#对Map元素的引用的方法：p._1 p._2m.foreach((e: (String, Int)) => println("key=" + e._1 + ",
开发多线程程序时，需要注意那些问题
最新发布
OO_SEN的博客
08-23 538
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
Java学习：泛型方法与泛型类实例化
"该资源是一份关于Java课程的PPT，重点讲解了如何通过泛型方法返回泛型类实例，并涵盖了Java的学习概述、核心知识点、学习流程以及Java软件工程师所需的技术体系。" 在Java编程中，泛型是一种强大的工具，它允许在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值