Java-Collection集合（List系列）、泛型、可变参数及增强for循环

最新推荐文章于 2022-03-01 22:15:10 发布

种花家的羊

最新推荐文章于 2022-03-01 22:15:10 发布

阅读量101

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_45683833/article/details/104318171

版权

ArrayList的概述及使用

ArrayList的概述：
ArrayList是List的子类，而List又是Collection的子类
ArrayList的成员方法
因为ArrayList继承自List，而List又继承自Collection，所以父类未被私有的成员方法ArrayList均可使用
ArrayList的案例：

请编写程序，将自定义对象存储到ArrayList集合，使用泛型并遍历
a) 使用迭代器遍历
b) 使用列表迭代器遍历
c) 使用size()和get()方法遍历
d) 使用增强for遍历
package org.westos.demo2;

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

public class Demo {
    public static void main(String[] args) {
        List<Student> list = new ArrayList<>();
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 25));
        Iterator<Student> iterator = list.iterator();
        System.out.println("迭代器进行遍历");
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next);
        }
        System.out.println("列表迭代器进行遍历");
        ListIterator<Student> studentListIterator = list.listIterator();
        while (studentListIterator.hasNext()) {
            Student next = studentListIterator.next();
            System.out.println(next);
        }
        System.out.println("size()和get()方法进行遍历");
        for (int i = 0; i < list.size(); i++) {
            Student student = list.get(i);
            System.out.println(student);
        }
        System.out.println("使用增强for()循环进行遍历");
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Vector的概述及使用方法

Vector类概述：
Vector 类可以实现可增长的对象数组 , Vector 是同步的。
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集合，使用泛型并遍历
a) 使用迭代器遍历
b) 使用Vector特有的迭代器遍历
c) 使用size()和get()方法遍历
d) 使用增强for遍历
package org.westos.demo2;

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        Vector<Student> list = new Vector<>();
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 25));
        Iterator<Student> iterator = list.iterator();
        System.out.println("迭代器进行遍历");
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next);
        }
        System.out.println("Vector特有的迭代器进行遍历");
        Enumeration<Student> elements = list.elements();
        while (elements.hasMoreElements()) {
            Student next = elements.nextElement();
            System.out.println(next);
        }
        System.out.println("size()和get()方法进行遍历");
        for (int i = 0; i < list.size(); i++) {
            Student student = list.get(i);
            System.out.println(student);
        }
        System.out.println("使用增强for()循环进行遍历");
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

LinkedList的概述及使用方法

LinkedList类概述：
List 接口的链接列表实现 , 此实现不是同步的
LinkedList类特有功能：
public void addFirst(E e)
给集合最顶层添加元素
public void addLast(E e)
给集合的末尾添加元素
public E getFirst()
获取集合的首位元素
public E getLast()
获取集合的末尾元素
public E removeFirst()
删除集合的首位元素
public E removeLast()
删除集合的末尾元素
案例演示：

请编写程序，将自定义对象存储到LinkedList集合，使用泛型并遍历
a) 使用迭代器遍历
b) 使用列表迭代器遍历
c) 使用size()和get()方法遍历
d) 使用增强for遍历
package org.westos.demo2;

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        LinkedList<Student> list = new LinkedList<>();
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 22));
        list.add(new Student("王五", 25));
        Iterator<Student> iterator = list.iterator();
        System.out.println("迭代器进行遍历");
        while (iterator.hasNext()) {
            Student next = iterator.next();
            System.out.println(next);
        }
        System.out.println("列表迭代器进行遍历");
        ListIterator<Student> studentListIterator = list.listIterator();
        while (studentListIterator.hasNext()) {
            Student next = studentListIterator.next();
            System.out.println(next);
        }
        System.out.println("size()和get()方法进行遍历");
        for (int i = 0; i < list.size(); i++) {
            Student student = list.get(i);
            System.out.println(student);
        }
        System.out.println("使用增强for()循环进行遍历");
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

泛型概述和基本使用

泛型概述：
是一种把类型明确的工作，推迟到创建对象，或者调用方法的时候才去明确的特殊的类型。
参数化类型，把类型当作参数一样的传递。
泛型的格式：
<数据类型> 这里的数据类型只能是引用数据类型
注意事项: 泛型类型必须是引用类型
泛型好处：
(1): 把运行时期的问题提前到了编译期间
(2): 避免了强制类型转换
(3):优化了程序设计，解决了黄色警告线
注意：泛型只在编译期有效但在运行期就擦除了
泛型类的案例演示：
以上的三个集合案例均使用了泛型

泛型方法的案例，并可以返回泛型类型

public class Demo {
   		 public <T> T show(T a) {
       		 System.out.println(a);
       		 return a;
   		 }
		}

泛型接口的演示

package org.westos.demo4;

import java.util.Collection;

public interface MyInterface<T,U,R> { //泛型接口
    public R show(T t,U u);
}
//泛型接口上的泛型，什么时候名曲，你可以在子类里面去明确
class MyDemo implements MyInterface<String,Integer,Integer>{
    @Override
    public Integer show(String s, Integer integer) {
        return null;
    }
}

泛型高级之通配符

泛型高级的表达方式：
（1）:泛型通配符<?>: 任意类型，如果没有明确，那么就是* Object以及任意的Java类了
（2）: extends E ：泛型的向下限定，E及其子类
（3）: super E ：泛型的向上限定，E及其父类
案例演示：

class Animal {}
class Dog extends Animal{}
class Cat extends Animal{}
class GenericDemo {
public static void main(String[] args) {
Collection<Object> c = new ArrayList<Object>();
Collection<Animal> c1 = new ArrayList<Animal>();

Collection<? extends Animal> c5 = new ArrayList<Animal>();
Collection<? extends Animal> c6 = new ArrayList<Dog>();
Collection<? extends Animal> c7 = new ArrayList<Cat>();

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

}
}

增强for的概述和使用

增强for概述：
简化数组和Collection集合的遍历
格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
好处和注意事项：
简化遍历
注意事项：增强for的目标要判断是否为null
案例演示：
以上的三个集合的案例均使用了增强for()循环
再来一个数组增强for()循环的案例演示

public class MyTest {
    public static void main(String[] args) {
    int[] arr={20,40,50,60};
     for(int ele:arr){
            System.out.println(ele);
        }
    }     
}

可变参数的概述和使用

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

请编写程序，完成N个数 相加的功能，并测试
package org.westos.demo2;

public class Demo2 {
    public static void main(String[] args) {
        Integer sum = sum(1, 2, 3,4);
        System.out.println(sum);
    }
    public static Integer sum(Integer ...a){
        int sum=0;
        for (int i = 0; i < a.length; i++) {
            sum+=a[i];
        }
        return sum;
    }
}

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

Arrays工具类的asList(T… t)方法的使用:
将数组转换成集合
注意事项:
得到的集合长度是不可变的你不能往这个转换后的集合中添加元素（add）和删除元素(remove)，只能获取元素(get)
案例演示：

package org.westos.demo2;

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

public class MyTest2 {
    public static void main(String[] args) {
        //创建一个数组，遍历集合取出元素放到数组里面
        int[] arr = {20, 40, 50, 60};
        int[] arr2 = {20, 40, 50, 60};
        int[] arr3 = {20, 40, 50, 60};
        //把数组转换成集合
        List<int[]> ints = Arrays.asList(arr1,arr2,arr3);
        int[] ints1 = ints.get(0);

        //注意事项：通过asList转换过来的集合，该集合就不能再次添加元素或删除元素
        //只能获取元素来用
        //把数组转换成集合
        //如果你给的这个数组，是一个元素是基本类型的数组，他是把这个数组对象装到集合里面
        List<int[]> int3 = Arrays.asList(arr3);
        //如果你给的是一个引用类型的数组，他是把数组的元素取出来，放到集合中
        Integer[] integers2 = {10, 20, 30};
        List<Integer> integers1 = Arrays.asList(integers2);
        System.out.println(integers1);
        //如果你传了两个以上的对象数组，那么他是把两个对象数组，存到集合中
        List<Integer[]> integers3 = Arrays.asList(integers2, integers2);
    }
}

种花家的羊

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java-Collection集合（List系列）、泛型、可变参数及增强for循环

ArrayList的概述及使用ArrayList的概述：ArrayList是List的子类，而List又是Collection的子类ArrayList的成员方法因为ArrayList继承自List，而List又继承自Collection，所以父类未被私有的成员方法ArrayList均可使用ArrayList的案例：请编写程序，将自定义对象存储到ArrayList集合，使用泛型并遍...
复制链接

扫一扫