2020.8.5Java基础总结16_ArrayList、Vector、LinkedList类、泛型、增强For、可变参数

最新推荐文章于 2024-09-29 08:33:21 发布

砖厂打工仔

最新推荐文章于 2024-09-29 08:33:21 发布

阅读量132

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_42456748/article/details/107836146

版权

本文总结了Java中ArrayList、Vector和LinkedList集合的特点和常用方法，详细介绍了泛型的概念、好处及使用方式，包括类、方法和接口中的泛型定义，以及增强For循环和可变参数的用法。通过对这些基础概念的深入理解，有助于提升Java编程能力。

摘要由CSDN通过智能技术生成

Java基础总结16

一、ArrayList集合

1.1 概述

ArrayList是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操作内部存储的元素。 ArrayList中可不断添加元素，其大小也自动增长。

1.2 常用方法

public boolean add(E e)：将指定的元素添加到此集合的尾部。
public E remove(int index)：移除此集合中指定位置上的元素。返回被删除的元素。
public E get(int index)：返回此集合中指定位置上的元素。返回获取的元素。
public int size()：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。

方法演示：

public class Demo01ArrayListMethod {
	public static void main(String[] args) {
		//创建集合对象
		ArrayList<String> list = new ArrayList<String>();
		//添加元素
		list.add("hello");
		list.add("world");
		list.add("java");
		//public E get(int index):返回指定索引处的元素
		System.out.println("get:"+list.get(0));
		System.out.println("get:"+list.get(1));
		System.out.println("get:"+list.get(2));
		//public int size():返回集合中的元素的个数
		System.out.println("size:"+list.size());
		//public E remove(int index):删除指定索引处的元素，返回被删除的元素
		System.out.println("remove:"+list.remove(0));
		//遍历输出
		for(int i = 0; i < list.size(); i++){
		System.out.println(list.get(i));
		}
	}
}

1.3 练习

ArrayList去除集合中字符串的重复值(字符串的内容相同)，采用创建新集合的方式。

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

public class Test2 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(1);
        list.add(200);
        list.add(100);
        list.add(400);
        list.add(600);
        Iterator iterator = list.iterator();
        List newList=new ArrayList();
        while (iterator.hasNext()) {
            Object obj = iterator.next();
            if(!newList.contains(obj)){
                newList.add(obj);
            }
        }
        System.out.println(newList);
    }
}

二、Vector集合

2.1 概述

Vector 类可以实现可增长的对象数组 , Vector 是同步的。

2.2 常用方法(特有)

public void addElement(E obj)： 将指定的组件添加到此向量的末尾，将其大小增加 1。
public E elementAt(int index)： 返回指定索引处的组件。
public Enumeration elements()： 返回此向量的组件的枚举。

三、LinkedList集合

3.1 概述

LinkedList集合数据存储的结构是链表结构，方便元素添加、删除的集合。此实现不是同步的。

3.2 常用方法(特有)

public void addFirst(E e)：将指定元素插入此列表的开头。
public void addLast(E e)：将指定元素添加到此列表的结尾。
public E getFirst()：返回此列表的第一个元素。
public E getLast()：返回此列表的最后一个元素。
public E removeFirst()：移除并返回此列表的第一个元素。
public E removeLast()：移除并返回此列表的最后一个元素。
public E pop()：从此列表所表示的堆栈处弹出一个元素。
public void push(E e)：将元素推入此列表所表示的堆栈。
public boolean isEmpty()：如果列表不包含元素，则返回true。

方法演示：

public class LinkedListDemo {
    public static void main(String[] args) {
        LinkedList<String> link = new LinkedList<String>();
        //添加元素
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        System.out.println(link);
        // 获取元素
        System.out.println(link.getFirst());
        System.out.println(link.getLast());
        // 删除元素
        System.out.println(link.removeFirst());
        System.out.println(link.removeLast());

        while (!link.isEmpty()) { //判断集合是否为空
            System.out.println(link.pop()); //弹出集合中的栈顶元素
        }
        System.out.println(link);
    }
}

四、泛型

4.1 概述

可以在类或方法中预支地使用未知的类型。

提示：一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

4.2 使用泛型的好处

把运行时期的问题提前到了编译期间。
避免了类型强转的麻烦。

注意：泛型只在编译期有效但在运行期就擦除了

使用泛型后的演示代码：

public class GenericDemo2 {
	public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("123");
        // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
	}
}

4.3 泛型的定义和使用

4.3.1 含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){ }
     ...
}

4.3.2 含有泛型的方法

定义格式：

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

例如：

public class MyGenericMethod {	  
    public <T> void show(T t) {
    	System.out.println(t.getClass());
    }
    public <T> T show2(T t) {	
    	return t;
    }
}

使用格式：

调用方法时，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

4.3.3 含有泛型的接口

定义格式：

修饰符 interface 接口名<代表泛型的变量> {  }

例如：

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：

1、定义类时确定泛型的类型。

public class MyClass1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

例如：

public class MyClass2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

public class GenericInterface {
    public static void main(String[] args) {
        MyClass2<String>  my = new MyClass2<String>();  
        my.add("aa");
    }
}

4.4 泛型通配符

4.4.1 通配符的使用

不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

比如：

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}
public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

注意事项：

泛型不存在继承关系 Collection<Object> list = new ArrayList<String>();这种是错误的。

4.4.2 受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

格式：类型名称 <? extends 类 > 对象名称
意义：只能接收该类型及其子类

泛型的下限：

格式：类型名称 <? super 类 > 对象名称
意义：只能接收该类型及其父类

例如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类。

import java.util.ArrayList;
import java.util.Collection;

public class Test2 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();
        Collection<Float> list5 = new ArrayList<>();
        
        getElement(list1);
        getElement(list2);//报错
        getElement(list3);
        getElement(list4);//报错
        getElement(list5);

        getElement2(list1);//报错
        getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);
        getElement2(list5);//报错
    }
    //泛型的上限
    private static void getElement(Collection < ? extends Number> coll) {

    }
    //泛型的下限
    private static void getElement2(Collection < ? super Number> coll) {

    }
}

五、增强for循环

概述：
增强for循环(也称for each循环)是JDK1.5以后出来的一个高级for循环，专门用来遍历数组和集合的。它的内部原理其实是个Iterator迭代器，所以在遍历的过程中，不能对集合中的元素进行增删操作。
格式：
```
for(元素的数据类型  变量 : Collection集合or数组){ 
  	//操作代码
}
```
它用于遍历Collection集合和数组。通常只进行遍历元素，不要在遍历的过程中对集合元素进行增删操作。

练习1：遍历数组:

public class NBForDemo1 {
    public static void main(String[] args) {
		int[] arr = {3,5,6,87};
       	//使用增强for遍历数组
		for(int a : arr){//a代表数组中的每个元素
			System.out.println(a);
		}
	}
}

练习2：遍历集合：

public class NBFor {
    public static void main(String[] args) {        
    	Collection<String> coll = new ArrayList<String>();
    	coll.add("aaa");
    	coll.add("bbb");
    	coll.add("ccc");
    	//使用增强for遍历
    	for(String s :coll){//接收变量s代表 代表被遍历到的集合元素
    		System.out.println(s);
    	}
	}
}

六、可变参数

在JDK1.5之后，如果我们定义一个方法需要接受多个参数，并且多个参数类型一致，我们可以对其简化成如下格式：

修饰符 返回值类型 方法名(参数类型... 形参名){  }

注意事项：
- 这里的参数其实是一个数组。
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个。

代码演示：

public class ChangeArgs {
    public static void main(String[] args) {
        int[] arr = { 1, 4, 62, 431, 2 };
        int sum = getSum(arr);
        System.out.println(sum);
    }
    /*
    原始写法，完成数组元素求和
     public static int getSum(int[] arr){
        int sum = 0;
        for(int a : arr){
            sum += a;
        }
        return sum;
      }
    */
    //可变参数写法
    public static int getSum(int... arr) {
        int sum = 0;
        for (int a : arr) {
            sum += a;
        }
        return sum;
    }
}