JAVA中的List，以及泛型的基本使用

最新推荐文章于 2025-07-08 16:59:07 发布

原创最新推荐文章于 2025-07-08 16:59:07 发布 · 1.4w 阅读

6 ·

CC 4.0 BY-SA版权

JAVA 专栏收录该内容

23 篇文章

订阅专栏

本文介绍了JAVA中Vector和LinkedList的特有功能，包括添加、获取和移除元素的方法。接着详细探讨了泛型，包括泛型概述、泛型类、泛型方法、泛型接口以及通配符的使用。此外，还讲解了增强for循环、可变参数和Arrays工具类的asList()方法的应用。最后讨论了ArrayList嵌套ArrayList的集合嵌套情况。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Vector的特有功能

A:Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
B:Vector类特有功能
public void addElement(E obj)
public E elementAt(int index)
public Enumeration elements()

LinkedList的特有功能

A:LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的
B:LinkedList类特有功能
public void addFirst(E e)及addLast(E e)
public E getFirst()及getLast()
public E removeFirst()及public E removeLast()
案例：
用LinkedList模拟栈数据结构的集合并测试

public class MyTest {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();
        myStack.addEle(100);
        myStack.addEle(200);
        myStack.addEle(300);
        myStack.addEle(400);
        myStack.addEle(500);

        Object o = myStack.get();
        System.out.println(o);
        Object o2 = myStack.get();
        System.out.println(o2);

        Object o3 = myStack.get();
        System.out.println(o3);
        Object o4 = myStack.get();
        System.out.println(o4);
        Object o5 = myStack.get();
        System.out.println(o5);
        Object o6= myStack.get();
        System.out.println(o6);
    }
}
class MyStack {
    LinkedList linkedList;
    public MyStack() {
        linkedList= new LinkedList();
    }

    public void addEle(Object obj){
        linkedList.addFirst(obj);
    }

    public Object get(){

        Object poll = linkedList.poll();

  
        linkedList.addLast(poll);

        return poll;

    }

}

去除ArrayList中重复自定义对象元素

  public static void main(String[] args) {


        ArrayList list = new ArrayList();
        list.add("abc");
        list.add("bbb");
        list.add("abc");
        list.add("abc");
        list.add("ccc");
        list.add("ddd");
        list.add("ccc");
        list.add("ddd");
        ArrayList newList = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            String s = (String) list.get(i);
            if(!newList.contains(s)){
                newList.add(s);
            }
        }

        System.out.println(newList);

    }

public static void main(String[] args) {

    ArrayList list = new ArrayList();
    list.add("abc");
    list.add("bbb");
    list.add("abc");
    list.add("abc");
    list.add("ccc");
    list.add("ddd");
    list.add("ccc");
    list.add("ddd");
    ArrayList newList = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        String s = (String) list.get(i);
        if(!newList.contains(s)){
            newList.add(s);
        }
    }

    System.out.println(newList);

}

泛型

泛型概述和基本使用

A:泛型概述:是一种把类型明确的工作
推迟到创建对象
或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
B:泛型的格式 : <数据类型> 这里的数据类型只能是引用数据类型
C:泛型好处
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效但在运行期就擦除了
例：ArrayList存储自定义对象并遍历泛型版

public class Demo2 {
    public static void main(String[] args) {
        ArrayList list=new ArrayList();
        ListIterator listIterator = list.listIterator();



        Collection<Phone> phones = new ArrayList<>();
        phones.add(new Phone("xiaomi",3000));
        phones.add(new Phone("apple",1000));
        phones.add(new Phone("huawei",5000));
        Iterator<Phone> iterator = phones.iterator();
        while (iterator.hasNext()){
            Phone next = iterator.next();
            System.out.println(next.getBrand()+"---"+next.getPrice());

        }

    }
}
class Phone{

    private String brand;
    private int price;

    public Phone(String brand, int price) {
        this.brand = brand;
        this.price = price;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getPrice() {
        return price;
    }

    public void setPrice(int price) {
        this.price = price;
    }


}

泛型类的概述及使用

A:泛型类概述: 把泛型定义在类上
B:定义格式: public class 类名<泛型类型1,…>
C:注意事项: 泛型类型必须是引用类型

泛型的应用之泛型类: 就是把泛型定义在类上
- 格式: public class 类名<数据类型 , …> {}
  */
  public class ObjectTools {
  private K k ;
  public K getK() {
  return k;
  }
  public void setK(K k) {
  this.k = k;
  }

}

泛型方法的概述和使用

A:泛型方法概述: 把泛型定义在方法上
B:定义格式: public <泛型类型> 返回类型方法名(泛型类型变量名)
C.泛型方法：
public void show(E e){
System.out.println(e);
}

泛型接口的概述和使用

A:泛型接口概述: 把泛型定义在接口上
B:定义格式: public interface 接口名<泛型类型>

泛型接口的子类: 第一种情况: 就是在定义子类的时候我们已经可以明确数据类型了

  
  public class InterImpl implements Inter<String> {
  
  	@Override
	public void show(String t) {
  		System.out.println(t);
  	}
  
  }

泛型接口的子类: 第二种情况: 就是在定义子类的时候我们还不知道到底使用神马数据类型.这个时候我们就需要将这个子类也定义成泛型

- public class InterImpl<T> implements Inter<T>  {
  @Override
  public void show(T t) {
  	System.out.println(t);
  }

}

泛型高级之通配符

A:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了
B:? extends E: 向下限定，E及其子类
C:? super E: 向上限定，E及其父类

泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
Collection col1 = new ArrayList() ;
Collection col2 = new ArrayList() ;//报错

表示任意的数据类型
Collection<?> col5 = new ArrayList() ;
Collection<?> col6 = new ArrayList() ;

? extends E : 向下限定 , ? 表示的是E或者E的子类
Collection<? extends Animal> col9 = new ArrayList() ;//报错
Collection<? extends Animal> col10 = new ArrayList() ;
Collection<? extends Animal> col11 = new ArrayList() ;

? super E: 向上限定 , ? 表示的是E或者E的父类
Collection<? super Animal> col13 = new ArrayList() ;
Collection<? super Animal> col14 = new ArrayList() ;

增强for的概述和使用

A:增强for概述
简化数组和Collection集合的遍历
B:格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
C:好处和注意事项
简化遍历
注意事项：增强for的目标要判断是否为null

public static void main(String[] args) {


        ArrayList<Integer> list = new ArrayList();
        list.add(100);
        list.add(200);
        list.add(300);
        list.add(400);
        list.add(500);
        list.add(600);
        list.add(700);
        list.add(800);
        list.add(900);
        for(Integer ele:list){
            System.out.println(ele);
        }

    }

可变参数的概述和使用

A:可变参数概述: 定义方法的时候不知道该定义多少个参数
B:格式: 修饰符返回值类型方法名(数据类型… 变量名){}
C:注意事项：
a: 这里的变量其实是一个数组
b: 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
可变参数
public static int add(int… a){
// 定义一个累加变量
int sum = 0 ;
for(int s : a ){
sum += s ;
}
return sum;
}

Arrays工具类的asList()方法的使用

将数组转为集合
注意事项: 得到的集合长度是不可变的你不能往这个转换后的集合中添加元素（add）和删除元素(remove)只能获取元素(get)

集合嵌套之ArrayList嵌套ArrayList

例：我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生

public class MyTest {
    public static void main(String[] args) {
     

        ArrayList<Student> javaList = new ArrayList<>();
        javaList.add(new Student("张三1", 23));
        javaList.add(new Student("张三2", 23));
        javaList.add(new Student("张三3", 23));

        ArrayList<Student> webList = new ArrayList<>();
        webList.add(new Student("张三4", 23));
        webList.add(new Student("张三5", 23));
        webList.add(new Student("张三6", 23));

        ArrayList<Student> linuxList = new ArrayList<>();
        linuxList.add(new Student("张三7", 23));
        linuxList.add(new Student("张三8", 23));
        linuxList.add(new Student("张三9", 23));

      
        ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
        maxList.add(javaList);
        maxList.add(webList);
        maxList.add(linuxList);
        for (ArrayList<Student> students : maxList) {
            for (Student student : students) {
                System.out.println(student.getName() + "===" + student.getAge());
            }
        }


    }
}
class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

   
    }
}