泛型类 泛型方法 Vector LinkedList

最新推荐文章于 2021-12-09 22:39:04 发布
最新推荐文章于 2021-12-09 22:39:04 发布
阅读量243 收藏 1
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52946124/article/details/115435500
版权

1、请简述泛型是什么?有什么用?在哪里用？

2、请把今天讲解的方法，在API中查找到，并用自己的话进行描述

答案：

​ Vector

​ public void addElement(E obj)

Vector特有的的添加方法

​ public E elementAt(int index)

返回对应索引的元素

public boolean removeElement(Object obj)

根据集合中的元素删除元素

public void removeElementAt(int index)

根据集合中的索引删除元素

​ public void setElementAt(E obj, int index)

根据集合中的索引改变对相应的元素

​ public Enumeration elements()

Vector中特有的迭代器

​ Enumeration

​ public boolean hasMoreElements()

判断集合是否有元素

​ public Object nextElement()

获取集合中的元素

​ LinkedList：底层数据结构是链表，查询慢，增删快，线程不安全

​ public void addFirst(E e)

将指定元素添加到列表的开头

​ public void addLast(E e)

将指定元素添加到列表的末尾

​ public E getFirst()

获取列表中的第一个元素

​ public E getLast()

获取列表中的最后一个元素

​ public E removeFirst()

移除列表中的第一个元素

​ public E removeLast()

移除列表中的最后一个元素

3、请简述List<? extends T>和List<? super T>之间有什么区别？

List<? super T>向上限定：？代表T本身或者T的父类

List<? extends T>向下限定：？代表T本身或者T的子类

4、请简述如何编写一个泛型方法，让它能够接受泛型参数并返回泛型类型？并举例

public class MyDemo1 {
    public <P> void show(P p){//泛型方法
        System.out.println(p);
    }
}
class MyTest1{
    public static void main (String[] args) {
        MyDemo1 demo1 = new MyDemo1();
        demo1.show(100);
        demo1.show("acvacav");
    }

5、请简述Java中如何使用泛型编写带有参数的类？并举例

​ 在定义一个类的时候，可以给这个类给一个或者多个泛型（可以明确，也可以不明确），在这个类中提供set和get方法，在创建对象时可以给泛型明确具体的类型

public class MyDemo<S,I> {
    private S s;
    private I i;
    public S getS () {
        return s;
    }
    public void setS (S s) {
        this.s = s;
    }
    public I getI () {
        return i;
    }
    public void setI (I i) {
        this.i = i;
    }
}
class MyTest{
    public static void main (String[] args) {
        MyDemo<String, Integer> stringIntegerMyDemo = new MyDemo<>();
        stringIntegerMyDemo.setS("aaa");
        stringIntegerMyDemo.setI(100);
        String s = stringIntegerMyDemo.getS();
        Integer i = stringIntegerMyDemo.getI();
        System.out.println(s);
        System.out.println(i);
    }
}

B:看程序写结果(写出自己的分析理由)，程序填空，改错，看程序写结果。

1、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因。

class Test {

private T name;

public T getName() {

return name;

}

public void setName(T name){

this.name = name;

}

public static void main (String[] args) {

Test strTest = new Test();

strTest.setName(“aaa”);

System.out.println( strTest.getName() );

Test intTest = new Test();

intTest.setName(1234);

System.out.println( intTest.getName() );

}

}

结果：

aaa
1234

2、给出以下代码，如有问题，请说明原因。

需求：定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据

public static void printCollection (Collection cols) {

for (Object obj : cols) {

System.out.println( obj );

}

}

Collection参数类型不需要给出泛型

class  Test{
        public static void printCollection(Collection cols){
            for (Object obj : cols) {
                System.out.println(obj);
            }
        }
}
class MyTest3{
    public static void main (String[] args) {
        Collection<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        Test.printCollection(integers);
        LinkedList<String> strings = new LinkedList<>();
        strings.add("aaa");
        strings.add("bbbb");
        strings.add("cccc");
        Test.printCollection(strings);
    }
}

3、 给出以下代码，如有问题，请说明原因。

class Animal {}

class Dog extends Animal{}

class Cat extends Animal{}

class GenericDemo {

public static void main(String[] args) {

Collection c = new ArrayList();

Collection c1 = new ArrayList();

Collection c2 = new ArrayList();

//改：Collection c2 = new ArrayList<>();

Collection c3 = new ArrayList();

//改：Collection c3 = new ArrayList<>();

Collection<? extends Animal> c4 = new ArrayList();

//改：向下限定Collection<? extends Animal> c4 = new ArrayList<Animal的子类或者本身>();

Collection<? extends Animal> c5 = new ArrayList();

Collection<? extends Animal> c6 = new ArrayList();

Collection<? extends Animal> c7 = new ArrayList();

Collection<? super Animal> c8 = new ArrayList();

Collection<? super Animal> c9 = new ArrayList();

Collection<? super Animal> c10 = new ArrayList();

Collection<? super Animal> c11 = new ArrayList();

//改：向上限定Collection<? super Animal> c10 = new ArrayList<Animal的本身或者父类>();

Collection<? super Animal> c11 = new ArrayList<Animal的本身或者父类>();

}

}

4、给出以下代码，请问该程序的运行结果是什么？如有问题，请说明原因。

interface Inter {

public abstract void method();

}

class SubEx implements Inter {

public void method() {

System.out.println(“SubEx”);

}

}

class GenericTest {

public static void main (String[] args) {

List list = new ArrayList();

SubEx se = new SubEx();

list.add(se);

printList1(list);

printList2(list);

printList3(list);

printList4(list);

}

public static void printList1 (List<? extends Inter> list) {

for (Inter in : list) {

in.method();

}

}

public static void printList2 (List<?> list) {

for (Object obj : list) {

((Inter)obj).method();

}

}

public static void printList3 (List list) {//List< SubEx> list)

for (Inter in: list) {

in.method();

}

}

public static void printList4 (List list) {//List list

for (Object obj : list) {

((Inter)obj).method();

}

}

}

结果：

SubEx
SubEx
SubEx
SubEx

C:编程题

1、请编写程序，将自定义对象存储到ArrayList集合，使用泛型并遍历

a) 使用迭代器遍历、

b) 使用列表迭代器遍历

c) 使用size()和get()方法遍历

d) 使用增强for遍历

public class MyArrayList {
    public static void main (String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        integers.add(1000);
        integers.add(1);
        integers.add(2);
        //列表迭代器遍历
        ListIterator<Integer> integerListIterator = integers.listIterator();
        while (integerListIterator.hasNext()) {
            Integer next = integerListIterator.next();
            System.out.println(next);
        }
        System.out.println("-------------------");
        //迭代器遍历
        Iterator<Integer> iterator = integers.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
        }
        System.out.println("-------------------");
        //使用size()和get()方法遍历
        for(int i=0;i<integers.size();i++){
            Integer integer = integers.get(i);
            System.out.println(integer);
        }
        System.out.println("-------------------");
        //forEach方法遍历
        integers.forEach(new Consumer<Integer>() {
            @Override
            public void accept (Integer integer) {
                System.out.println(integer);
            }
        });
        System.out.println("-------------------");
        //新式for循环
        for (Integer integer : integers) {
            System.out.println(integer);
        }
    }
}

2、请编写程序，将自定义对象存储到Vector集合，使用泛型并遍历

a) 使用迭代器遍历

b) 使用Vector特有的迭代器遍历

c) 使用size()和get()方法遍历

d) 使用增强for遍历

public class MyVector {
    public static void main (String[] args) {
        Vector<Integer> vector = new Vector<>();
        vector.add(100);
        vector.add(1000);
        vector.add(1);
        vector.add(2);
        //使用迭代器遍历
        Iterator<Integer> iterator = vector.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
        }
        System.out.println("--------------");
        //使用Vector特有的迭代器遍历
        Enumeration<Integer> elements = vector.elements();
        while (elements.hasMoreElements()) {
            Integer integer = elements.nextElement();
            System.out.println(integer);
        }
        System.out.println("-----------------");
        //使用size()和get()方法遍历
        for (int i = 0; i < vector.size(); i++) {
            Integer integer1 = vector.get(i);
            System.out.println(integer1);
        }
        System.out.println("-----------------");
        //使用增强for遍历
        for (Integer integer2 : vector) {
            System.out.println(integer2);
        }
    }
}

3、请编写程序，将自定义对象存储到LinkedList集合，使用泛型并遍历

a) 使用迭代器遍历

b) 使用列表迭代器遍历

c) 使用size()和get()方法遍历

d) 使用增强for遍历

public class MyLinkedList {
    public static void main (String[] args) {
        LinkedList<Integer> linkedList = new LinkedList<>();
       linkedList.add(100);
       linkedList.add(1000);
       linkedList.add(1);
       linkedList.add(2);
       //使用迭代器遍历
        Iterator<Integer> iterator = linkedList.iterator();
        while (iterator.hasNext()) {
            Integer next = iterator.next();
            System.out.println(next);
        }
        System.out.println("----------------");
        //使用列表迭代器遍历
        ListIterator<Integer> integerListIterator = linkedList.listIterator();
        while (integerListIterator.hasNext()) {
            Integer next = integerListIterator.next();
            System.out.println(next);
        }
        System.out.println("----------------");
        // 使用size()和get()方法遍历
        for (int i = 0; i < linkedList.size(); i++) {
            Integer integer = linkedList.get(i);
            System.out.println(integer);
        }
        System.out.println("----------------");
        //使用增强for遍历
        for (Integer integer : linkedList) {
            System.out.println(integer);
        }
    }
}

4、请编写程序，完成N个数 相加的功能，并测试

public class Plus {
    public static void main (String[] args) {
        int sum= add(1,12,4,5,6);//传入的参数就是要相加的数
        System.out.println(sum);
    }
    private static int add (int... n) {//可变参数
        int sum=0;
        for (int i : n) {//新式for循环
            sum+=i;
        }
        return sum;
    }
}
黑马程序员-- java集合类--Vector/泛型
whf769的专栏
06-10 1327
  集合类--Vector/泛型   Java用集合类来容纳不同种类的数据，java.util包中提供的向量(Vector)类就是集合类的一种。       该类是Java语言为解决数组长度和元素类型不能改变而引入的集合类，用来表示线性数据结构。 构造方法     public Vector()：创建一个空向量对象     public Vector(int initialCapacity)：使用
Java基础----ArrayList、Vector、LinkedList、泛型(Generic)
qq_62520680的博客
12-06 368
1. ArrayList遍历 除了迭代器和普通for循环遍历外，JDK1.8新增的一个方法也能遍历集合： void forEach(Consumer<? super E> action) 执行特定动作的每一个元素的 Iterable，直到所有元素都被处理或操作抛出异常 1.1 ArrayList存储自定义对象并遍历 自定义一个Student类 package Demo1; ​ /** * @Author: King * @Description:人类的伟大是勇气的伟大，人类的赞歌是
2021-06-11
weixin_51615667的博客
06-11 919
6-2 根据要求，使用泛型和LinkedList编写StringList类，实现QQ号码查找的功能。 (30 分) 已知数组存放一批QQ号码，QQ号码最长为11位，最短为5位： String[] strs = {“12345”,“67891”,“12347809933”,“98765432102”,“67891”,“12347809933”}。 将该数组里面的所有QQ号都存放在LinkedList中，然后遍历链表，将list中第一个指定长度的QQ号查找出来；如果不存在指定长度的QQ号，则输出“not exi
实现LinkList泛型类
sofency'Blog
07-04 258
package linkList; /** * @author sofency * */ public class SofencyLinkList03<E> { private Node first; //链表的最前一个元素 private Node last; //链表的最后一个元素 private int size;//链表的大小 //add方法实现 p...
java LinkedList<E>泛型类
csdn844460631的博客
10-09 701
一下是LinkedList泛型类的一些常用方法。 ①  public boolean add(E element)——向链表末尾添加一个新的节点，该节点中的数据是参数element指定的对象。 ②  public void add(int index, E element)——向链表的指定位置添加一个新的节点，该节点中的数据是参数element指定的对象。 ③  public void ad
6-4 根据要求，使用泛型和LinkedList编写StringList类，实现QQ号码查找的功能。 (30 分)java版
weixin_52445323的博客
12-09 1316
class StringList { public LinkedList<String> constructList(String[] strs) { LinkedList<String> ll = new LinkedList<String>(); HashSet<Integer> hs = new HashSet<Integer>(); for (int i = 0; i < st
泛型LinkedList
hillspring
07-31 744
 using System;using System.Collections.Generic;using System.Text;namespace LinkedList_T_Sample{ public class Document { private string title; public string Title {
LinkedList<E>泛型类
语不惊人死不休
01-22 3051
使用LinkedList泛型类可以创建链表结构的数据对象。链表是由若干个节点组成的一种数据结构，每个节点含有一个数据和下一个节点的引用（单链表），或含有一个数据以及上一个节点的引用和下个节点的引用（双链表），节点的索引从0开始。链表适合动态改变其存储数据，如增加、删除节点等。 1、LinkedList对象 java.util包中的LinkedList泛型类创建的对象以链表结构存储数据，习惯上称
ArrayList-Vector-LinkedList-泛型-增强for
Luna_ll的博客
11-16 330
一.List集合的子实现类特点 1.ArrayList: 底层数据结构是数组的形式，满足数组结构的特点：查询快，增删慢       从线程安全问题来看：线程是不安全的，不同步，执行效率高。 2.Vector: 底层数据结构是数组的形式，查询快，增删慢。       从线程安全角度看：线程安全的一个类，同步，执行效率低 3.LinkedList: 底层数据结构是链接列表，特点：查询慢
Java泛型深入理解：强类型集合与泛型类
泛型(Generics)是Java 1.5引入的一个重要特性，它允许在类、接口和方法中使用类型参数，增强了代码的类型安全性和效率。泛型的主要目的是为了创建强类型集合类，避免在使用集合时进行不必要的类型转换，并在编译阶段...
自定义LinkedList
weixin_41047492的博客
12-26 171
package cn.sxt.mycollection; /**  * 自定义一个链表  * 增加小的封装、增加泛型  * @author Administrator  *  */ public class LinkedList05&lt;E&gt; {          private   Node  first;     private  Node  last;          pri...
泛型，迭代器，LinkedList<E>
weixin_34315665的博客
11-27 92
1 <e>里面只能填类，不能用基本数据类型，不过integer 这样的的也行 2在模板类（泛型类中）class demo<e>由于不知道e是那个,所有通常都是重写大家都有的toString()方法来调用 泛型的作用主要是为了建立具有类型安全的数据结构 如果没有泛型 LinkedList 使用add方法的时候，由于所有类都是object的子类，所以都可以添加 Str...
arraylist泛型 java_List；List的子类（ArrayList,LinkedList)；泛型；泛型通配符 (Java Day14)...
weixin_32831131的博客
02-15 363
一，List概述：是单列集合中的有序集合的顶层接口，属于 Collection 的子接口，除了拥有 Collection 的通用方法，还有自己的特有方法【有序集合的共性功能】。特点：存取有序【存放数据的顺序和取出数据的顺序一致】有索引【和数组相似 底层使用数组结构构成的】​存放数据可以重复特有方法：​add(int inde，E e)：在指定的索引位置上添加元素e​ remove(int inde...
Java 集合总结（4）LinkedList的使用及其迭代器
明月映雪的博客
03-25 714
集合的体系： ----------| Collection 单列集合的根接口 ----------------| List 如果实现了List接口的集合类，具备的特点： 有序，可重复。 --------------------| ArrayList ArrayList 底层是维护了一个Object数组实现 的， 特点: 查询速度快，增删慢。 什么时候使用ArrayList: 如果目前的数据是...
Iterator迭代器及泛型
weixin_44079370的博客
11-25 383
11.25知识点 1、Collection集合（单列集合最顶层的接口） 1.1 Collection接口定义的是所有单列集合中共性的方法，所有的单列集合都可以使用 1.2 List接口是Collection的子接口，它是一个有序的集合（存储和取出顺序相同）；可以存储重复的元素；有索引，可以使用普通for循环遍历 1.3 Set接口是Collection的子接口，（TreeSet和HashSet无序，LinkedHashSet是一个有序的集合）不允许存储重复的元素；没有索引，不能使用普通的for循环遍历 1.
集合泛型简介与常用方法
qq_33194230的博客
11-05 453
集合 什么是集合 概念 对象的容器，实现了对对象常用的操作 和数组的区别 数组长度固定，集合长度不固定 数组可以存储基本类型和引用类型，集合只能存储引用类型 位置 java.util.*; Collection体系 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tru7Wmy1-1604564315647)(https://raw.githubusercontent.com/836890151/Image/master/1.png)] Collection父接口 特点：
数据结构与算法分析（二） —— LinkedList泛型类的实现
TangowL
07-06 896
在学习数据结构与算法分析过程中，便于使用的LinkedList类的实现是个很好的练手项目，本博文将提供详细的代码，给出一个便于使用的LinkedList泛型类的实现。为了避免与类库中的类相混淆，我们将其命名为MyLinkedList。由于程序较长，也相对简单，不太想逐段分析，我们先将几个注意点指出，后面放出整段程序。很多关于接口的知识可以参阅 数据结构与算法分析（二） —— ArrayList泛型类
深度剖析Java数据结构之表（四）——LinkedList泛型类的实现
mixer_a的专栏
04-10 236
在Java中，LinkedList泛型类继承了AbstractSequentialListf泛型类，实现了List、Deque、Colneable和Serializable接口，定义如下： 该类的实现使用的是循环链表的结构，我们知道，一个链表的主要标志就是表头，所以一个LinkedList泛型类中一定要有一个头结点，链表的组成元素是结点，所以还需要在该类中定义一个结点的内部类，当然，也可以在外面...
常用的被泛型化的集合类
qq_41978199的博客
06-15 298
package T泛型;import java.util.ArrayList;import java.util.HashMap;import java.util.Map;import java.util.Vector;/* * 常用的被泛型化的集合类 * 集合类                                           泛型定义 * ArrayList        Ar...
JAVA 基础知识整理-12（集合类）Vector, LinkedList, 泛型，增强for循环
KathyLJQ的博客
03-16 174
1. 集合类 数组和集合的区别： 数组 集合 长度固定 长度可变 只能存储同一种类型的元素 可以存储不同类型的元素 可以存储基本数据类型也可以存储引用数据类型 只能存储引用类型 JAVA 中集合的关系图： 2. Collection接口 Collection是集合的顶层接口，它的子体系有重复的，有唯一的，有有序的，有无序的。 主要方法： boolean add(E e...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值