List( ArrayList Vector LinkedList) 泛型(Generic) 增强for 可变参数的概述和使用

我会带着你远行 2021-12-03 14:47 97阅读 0赞

## List( ArrayList Vector LinkedList) 泛型(Generic) 增强for 可变参数的概述和使用 ##

（一）List

1.List概述及特点:

2.List常用的方法

3.List的三个子类特点

4.ArrayList

5.Vector

6.LinkedList

(二)泛型(Generic)

1.泛型的由来

2.泛型类的使用

3.泛型高级之通配符

（三）增强for

（四）可变参数的概述和使用

# （一）List #

### 1.List概述及特点: ###

元素有序,并且每一个元素都存在一个索引.元素可以重复.

### 2.List常用的方法 ###

List:

public void add(int index, Object element) 
        在列表的指定位置插入指定元素（可选操作）。
        public Object remove(int index) 
         移除列表中指定位置的元素（可选操作）。
        public Object set(int index, Object element)
        用指定元素替换列表中指定位置的元素（可选操作）。
         public Object get(int index) 
        返回列表中指定位置的元素。
        public ListIterator listIterator()
        列表迭代器(List集合特有的迭代器)

### 3.List的三个子类特点 ###

ArrayList:  
 底层数据结构是数组，查询快，增删慢。  
 线程不安全，效率高。  
 Vector:  
 底层数据结构是数组，查询快，增删慢。  
 线程安全，效率低。  
 LinkedList:  
 底层数据结构是链表，查询慢，增删快。  
 线程不安全，效率高。

\[^\]: List有三子类，我们到底使用谁呢? 得看 要安全还是要效率 是查找多还是增删多

### 4.ArrayList ###

##### 存储字符串并遍历 #####

##### a）使用迭代器遍历 #####

**public class** Demo1 {
         **public static void** main(String[] args) {
             ArrayList<Integer> integers = **new** ArrayList<>();
             integers.add(10);
             integers.add(100);
             integers.add(1000);
             integers.add(123);
             Iterator<Integer> iterator = integers.iterator();
             **while** (iterator.hasNext()) {
                 Integer next = iterator.next();
                 System.**out**.println(next);
             }
         }
     }

**b)** **使用列表迭代器遍历**

public class Demo1 {
        public static void main(String[] args) {
            ArrayList<Integer> integers = new ArrayList<>();
            integers.add(10);
            integers.add(100);
            integers.add(1000);
            integers.add(123);
            ListIterator<Integer> integerListIterator = integers.listIterator();
            while (integerListIterator.hasNext()) {
                Integer next = integerListIterator.next();
                System.out.println(next);
            }
        }
    }

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

public class Demo1 {
        public static void main(String[] args) {
            ArrayList<Integer> integers = new ArrayList<>();
            integers.add(10);
            integers.add(100);
            integers.add(1000);
            integers.add(123);
            for (int i = 0; i < integers.size(); i++) {
                Integer integer = integers.get(i);
                System.out.println(integer);
            }
            }
    }

**d)** **使用增强for\*\*\*\*遍历**

public class Demo1 {
        public static void main(String[] args) {
            ArrayList<Integer> integers = new ArrayList<>();
            integers.add(10);
            integers.add(100);
            integers.add(1000);
            integers.add(123);
            for (Integer integer : integers) {
                System.out.println(integer);
            }
            }
            }

### 5.Vector ###

#### 1.Vector的特有功能 ####

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

### 6.LinkedList ###

#### 1.LinkedList的特有功能 ####

1:LinkedList类概述: List 接口的链接列表实现 , 此实现不是同步的  
2:LinkedList类特有功能  
public void addFirst(E e)及addLast(E e)  
public E getFirst()及getLast()  
public E removeFirst()及public E removeLast()

# (二)泛型(Generic) #

### 1.泛型的由来 ###

泛型的由来:通过Object转型问题引入  
早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。  
也就存在这隐患，所以Java提供了泛型来解决这个安全问题。

**1.泛型是JDK1.5之后引入的一种机制，把类型明确工作推迟到创建对象或者调用方法时；**

\*\*泛型格式<\*\***数据类型>** **这里的数据类型指的是引用数据类型**

**2\*\*\*\*可以提高代码的灵活性和扩展性**

### 2.泛型类的使用 ###

\*\*\*\***可以在类** **接口** **和** \*\*方法上

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

*  泛型的应用之泛型类: 就是把泛型定义在类上
 *  格式: public class 类名<数据类型 , …> \{\}

2.把泛型定义在方法上  
B:定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)

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

### 3.泛型高级之通配符 ###

A:泛型通配符<?>: 任意类型，如果没有明确，那么就是Object以及任意的Java类了  
B:? extends E: 向下限定，E及其子类  
C:? super E: 向上限定，E及其父类  
D:案例演示: 泛型高级之通配符的基本使用

List<? extends E>**  **向下限定  ?** **表示的是E****或者E****的子类**
    **例如：**
    Collection<? extends Animal> co = new ArrayList<Animal>() ;          
    Collection<? extends Animal> co1 = new ArrayList<Dog>() ;
    **List<? super E>**    **向上限定   ?** **表示的是E****或者E****的父类**
    **例如：**
    **Collection<? super Animal> co = new ArrayList<Object>() ;**
    **Collection<? super Animal> co1 = new ArrayList<Animal>() ;**

# （三）增强for #

### 1增强for的概述和使用 ###

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

举例,ArrayList遍历增强for版

public class Demo1 {
        public static void main(String[] args) {
            Vector<Integer> integers = new Vector<>();
            integers.add(10);
            integers.add(100);
            integers.add(1000);
            integers.add(123);
            for (Integer integer : integers) {
              System.out.println(integer);
            }
            }
            }

# （四）可变参数的概述和使用 #

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

举例1\*\*1请编写程序，完成N个数加的功能，并测试

public class Tste {
        public static void main(String[] args) {
            int sum =add(1,11,1,1,1,1,1);
            System.out.println(sum);
        }
        private static int add(int b,int ... num) {
            int sum=0;
            for (int i : num) {
                sum+=i;
            }
            return sum+b;
        }
    }