JAVA SE之面向对象11：泛型与集合

yzlzszb

于 2021-05-24 20:20:28 发布

阅读量183

点赞数

文章标签： javase 集合泛型

本文链接：https://blog.csdn.net/yzl109zj125/article/details/117230812

版权

今日内容

1.ArrayList存储字符串

使用迭代器进行遍历

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 24));
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));

        ListIterator<Student> studentListIterator = list.listIterator();
        while (studentListIterator.hasNext()) {
            Student next = studentListIterator.next();
            System.out.println(next);
        }
    }
 }

使用for循环遍历

public class Test {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("张三", 23));
        list.add(new Student("张三", 23));
        list.add(new Student("李四", 24));
        list.add(new Student("李四", 24));
        list.add(new Student("王五", 25));
        list.add(new Student("赵六", 26));
        for (int i = 0; i < list.size(); i++) {
            Student student = list.get(i);
            System.out.println(student);
        }
    }
}

2.Vector特有功能

Vector类概述: Vector 类可以实现可增长的对象数组 , Vector 是同步的。
Vector类特有功能
- public void addElement(E obj)
- public E elementAt(int index)
- public Enumeration elements()
- E firstElement() 返回此向量的第一个组件（位于索引 0) 处的项）。
- E lastElement() 返回此向量的最后一个组件。
- void insertElementAt(E obj, int index) 将指定对象作为此向量中的组件插入到指定的 index 处。

3.LinkedList

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

练习1:去除ArrayList中重复字符串元素方式（不创建新集合）

使用选择排序法

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(205);
        list.add(2058);
        list.add(200);
        list.add(20);
        list.add(200);
        list.add(20);
        list.add(209);

        for (int i = 0; i < list.size() - 1; i++) {
            for (int j = i + 1; j < list.size(); j++) {
                if (list.get(i).equals(list.get(j))) {
                    list.remove(j);
                    j--; 
                }
            }
        }
        System.out.println(list);
    }
}

使用递归法

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(205);
        list.add(2058);
        list.add(200);
        list.add(20);
        list.add(200);
        list.add(20);
        list.add(209);
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(205);
        list.add(2058);
        list.add(200);
        list.add(20);
        list.add(200);
        list.add(20);
        list.add(209);
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(205);
        list.add(2058);
        list.add(200);
        list.add(20);
        list.add(200);
        list.add(20);
        list.add(209);
        deleteEle(list);

        System.out.println(list);
    }

    private static void deleteEle(ArrayList<Integer> list) {
        for (int i = 0; i < list.size(); i++) {
            Integer ele = list.get(i);
            if (list.indexOf(ele) != list.lastIndexOf(ele)) {
                list.remove(ele);
                deleteEle(list); 
            }
        }
    }
}

练习2:去除ArrayList中重复字符串元素方式（创建新集合）

public class Test {
    public static void main(String[] args) {
        ArrayList list = new ArrayList();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        //去除重复元素
        System.out.println(list);
        //采用创建一个新容器
        ArrayList<Object> newList = new ArrayList<>();

        for (int i = 0; i < list.size(); i++) {
            String ele = (String) list.get(i);
            if (!newList.contains(ele)) {
                newList.add(ele);
            }
        }
        System.out.println(newList);
    }
}

4.泛型

概述
- 是一种把类型明确的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。
- 参数化类型，把类型当作参数一样的传递。
泛型的格式 : <数据类型> 这里的数据类型只能是引用数据类型
泛型好处
- 把运行时期的问题提前到了编译期间
- 避免了强制类型转换
- 优化了程序设计，解决了黄色警告线
泛型只在编译期有效但在运行期就擦除了
泛型的由来
- 泛型的由来:通过Object转型问题引入
  早期的Object类型可以接收任意的对象类型，但是在实际的使用中，会有类型转换的问题。

6.泛型类

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

public class MyObject<T> {
    private T obj;
    int num;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

7.泛型方法

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

public class MyObject {
    private Object obj;

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }
}

8.泛型接口

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

public interface MyInterface<E> {

    void show(E e);
}

9.泛型高级之通配符

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

	/**
		 * 泛型如果明确了数据类型以后,那么要求左右两边的数据类型必须一致
		 */
		Collection<Object> col1 = new ArrayList<Object>() ;
		Collection<Object> col2 = new ArrayList<Animal>() ;//报错
	
		// ? 表示任意的数据类型
		Collection<?> col5 = new ArrayList<Object>() ;
		Collection<?> col6 = new ArrayList<Animal>() ;
	
		// ? extends E : 向下限定	, ? 表示的是E或者E的子类
//		Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错
		Collection<? extends Animal> col10 = new ArrayList<Animal>() ;
		Collection<? extends Animal> col11 = new ArrayList<Dog>() ;

```java
	// ? super E:  向上限定 , ? 表示的是E或者E的父类
	Collection<? super Animal> col13 = new ArrayList<Object>() ;
	Collection<? super Animal> col14 = new ArrayList<Animal>() ;
	//		Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错

10.增强for的概述和使用

增强for概述：简化数组和Collection集合的遍历
格式：
for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}
案例演示
数组，集合存储元素用增强for遍历

public class MyTest {
    public static void main(String[] args) {
        int[] arr = {20, 30, 40, 50};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        System.out.println("=============================");
        //新式for循环 (数据类型 ele:容器名)
        //快速生成 arr.for
        for (int ele : arr) {
            System.out.println(ele);
        }
        System.out.println("================================");

        ArrayList<Integer> list = new ArrayList<>();
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(120);
        list.add(205);
        list.add(2058);
        list.add(200);
        list.add(20);
        list.add(200);
        list.add(20);
        list.add(209);
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("===========================");
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

好处和注意事项
简化遍历
注意事项：增强for的目标要判断是否为null
注意新式for循环，你在迭代集合的途中，不能增删元素，会报并发修改异常

11.可变参数的概述和使用

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

	// 可变参数
public static int add(int... a){
	// 定义一个累加变量
	int sum = 0 ;
	for(int s : a ){
		sum += s ;
	}
	return sum;
}

12.静态导入语法

import static java.lang.Math.random; 直接导入到静态方法
import static java.lang.Math.*; 可以使用统配符把Math类下的所有静态方法都导入


使用时可以不用写类名，直接调用方法即可
random();

练习：集合嵌套之ArrayList嵌套ArrayList

需求：我们班有学生，每一个学生是不是一个对象。所以我们可以使用一个集合表示我们班级的学生。ArrayList
但是呢，我们旁边是不是还有班级，每个班级是不是也是一个ArrayList。
而我现在有多个ArrayList。也要用集合存储，怎么办呢?
集合嵌套之ArrayList嵌套ArrayList
```
 // 定义大的集合
 ArrayList<ArrayList<Student>> allClassList = new  ArrayList<ArrayList<Student>>() ;
 
 // 创建每一个班的集合
 ArrayList<Student> jcClassList = new  ArrayList<Student>() ;
```

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

        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 27);
        Student s3 = new Student("王五", 23);

        Student s4 = new Student("赵六", 25);
        Student s5 = new Student("刘德华", 28);
        Student s6 = new Student("张学友", 30);

        ArrayList<Student> javaList = new ArrayList<>();
        javaList.add(s1);
        javaList.add(s2);
        javaList.add(s3);

        ArrayList<Student> webList = new ArrayList<>();
        webList.add(s4);
        webList.add(s5);
        webList.add(s6);

        ArrayList<ArrayList<Student>> maxList = new ArrayList<>();
        maxList.add(javaList);
        maxList.add(webList);
         //遍历嵌套集合。
        for (int i = 0; i < maxList.size(); i++) {
            ArrayList<Student> minList = maxList.get(i);
            for (int j = 0; j < minList.size(); j++) {
                Student student = minList.get(j);
                System.out.println(student.getName() + "===" + student.getAge());
            }
        }
        System.out.println("=================================");
        for (ArrayList<Student> students : maxList) {
            for (Student student : students) {
                System.out.println(student.getName() + "===" + student.getAge());
            }
        }
        System.out.println("====================================");
        maxList.forEach(new Consumer<ArrayList<Student>>() {
            @Override
            public void accept(ArrayList<Student> minList) {
                minList.forEach(new Consumer<Student>() {
                    @Override
                    public void accept(Student student) {
                        System.out.println(student.getName() + "===" + student.getAge());
                    }
                });
            }
        });
    }
}

//学生类
public 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;
    }

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