集合中的泛型及集合中元素的交换和删除联系

Java泛型详解

最新推荐文章于 2024-06-15 22:26:40 发布

伟哥狂拽苦炫带你飞

最新推荐文章于 2024-06-15 22:26:40 发布

阅读量313

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/qq_38808348/article/details/79133959

本文深入讲解Java泛型的概念与应用，包括泛型的基本语法、泛型接口与类的定义及使用方式，同时还介绍了如何利用泛型进行类型安全的集合操作，并通过实例演示了泛型在实际开发中的优势。

泛型表示的是元素中集合的类型

/**
     * 保存字符串
     */
    private static void fun1() {
        // 创建一个集合保存abcd 字符窜类型，E就代表要保存的元素的类型
        // 后面尖括号填的泛型要和前面填的泛型一致
        // jdk1.7出来的 菱形泛型：如果前面声明了泛型，后面的泛型可以省略不写 省略不写则表示类型一致
        ArrayList<String> List = new ArrayList<>();
        List.add("a");
        List.add("b");
        List.add("c");
        List.add("d");
        Iterator<String> iterator = List.iterator();
        while (iterator.hasNext()) {
            //添加泛型之后可以省去强转类型的麻烦
            String next = iterator.next();
            System.out.println(next);
        }
    }
}

/**
     * 编译期报错
     */
    private static void fun2() {
        ArrayList<Student> students = new ArrayList<>();
        students.add(new Student("鹏鹏",17));
        students.add(new Student("水水",17));
        students.add(new Student("倩倩",17));
        //获取迭代器
        Iterator<Student> iterator = students.iterator();
         Student next = iterator.next();
        System.out.println(next.getName());
        //泛型的好处是把运行期的报错转换为编译器的报错

    }

//泛型接口
interface InterA<Z>{
    public abstract void fun(Z z);
}
//实现类
class InterAIpml implements InterA<String>{

    @Override
    public void fun(String z) {
        System.out.println(z);

    }   
}

//创建实现类
        InterAIpml  interAIpml =new InterAIpml();
        interAIpml.fun("哈哈哈有点意思");

/*
* 泛型类(泛型类声明时尖括号中的字母可以随便定义)
* 泛型类的类型在初始化这个类的对象的时候确定
* 要求你能看懂就行
*/

public class Worker<W> {
    //利用泛型写成员变量
    private W  w;
    //利用泛型写 set get 方法
    public W getW() {
        return w;
    }



    public void setW(W w) {
        this.w = w;
    }
    //普通的 成员方法
    public void sayHi(W w) {
        System.out.println(w);
    }
    //除了w还能不能使用其他的泛型 例如 Z 
    //声明不同泛型的方法 在调用泛型方法指定泛型的类型
    //<Z>声明一个泛型 只有声明过的才能使用
    public<Z> void print(Z z) {
        System.out.println(z);
    }
 //静态方法中能不能直接使用w 肯定不能
    //当你调用静态方法的时候可能还没有对象 没有对象就没声明没指令，所以不能用
    public  static<Z> void fun(Z z) {
        System.out.println(z);
    }


//工作的方法
    public void work() {
        System.out.println("天天搬砖，一天搬400块");
    }   
}

泛型类的测试

private static void fun3() {
        //创建泛型类
        Worker<String> worker = new Worker<>();
        //给属性赋值
        worker.setW("haha");
        System.out.println(worker.getW());
        //调用成员方法
        worker.sayHi("hahaha");
        //调用方法的时候给定类型
        worker.print("你好");
        //调用静态方法
        Worker.fun("真的很不错");
    }

创建一个人类和学生类
//人类

public class Person {
    private String name;
    private int age;
    public Person() {
        super();
        // TODO Auto-generated constructor stub
    }
    public Person(String name, int age) {
        super();
        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 "Person [name=" + name + ", age=" + age + "]";
    }

}

//学生类

public class Student extends Person{

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age) {
        super(name, age);
        // TODO Auto-generated constructor stub
    }


}

/*
* ? extends E（向下限定）
* ? 是子类 E是父类？只能是E类的子类
* ? super E （向上限定
* ? 是父类 E是子类） ?只能是E的父类
*
*/
将保存两个学生的集合添加到保存两个人的集合中

rivate static void fun1() {
        // 创建一个保存两人的集合
                ArrayList<Person> pArrayList = new ArrayList<>();
                pArrayList.add(new Person("王一", 17));
                pArrayList.add(new Person("李四", 19));
                //创建一个保存两个学生的集合
                ArrayList<Student> sArrayList = new ArrayList<>();
                sArrayList.add(new Student("鹏鹏",17));
                sArrayList.add(new Student("倩倩",18));
                //学生的集合全部添加到人的集合中
                // ? extend E 只能填person的子类
                pArrayList.addAll(sArrayList);
                System.out.println(pArrayList);
    }
}

private static void fun2() {
// Arrays 类方法 把数组转化为一个集合
int[] array = {1,2,3,4,5};//没有经过自动装箱
//把数组当做集合中的一个元素转为了集合
List<int[]> asList = Arrays.asList(array);
System.out.println(asList.size());
Integer[] array1 = {1,2,5,6,7};//自动装箱为Integer 类型
List<Integer> asList2 = Arrays.asList(array1);
System.out.println(asList2);
String [] array3 = {"wanglong","wangsong"};
List<String> asList3 = Arrays.asList(array3);
System.out.println(asList3);
//把王建忠添加到集合中
//如果你是使用 aslist数组转集合 得到一个集合
//注意这个集合不允许经行添加和删除的操作
//asList3.add("wangzhong");
//System.out.println(asList3);
//这么转的意义何在？ 可以调用集合的其他方法
boolean contains = asList3.contains("wanglong");
System.out.println(contains);
}

集合中的删除
//删除集合中的相同元素

public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("b");
        arrayList.add("d");
        arrayList.add("e");
        fun1(arraylist);
        fun2(arraylist);

    }

//不使用迭代器

private static void fun1(ArrayList<String> arrayList) {
        for (int i = 0; i < arrayList.size(); i++) {
            if (arrayList.get(i).equals("b")) {
                // 先当参数传进去再自减
                arrayList.remove(i--);
            }
        }
        System.out.println(arrayList);
    }
}

//使用迭代器遍历

public static viod fun2(){
   Iterator iterator= arraylist.Iterator;
   while(iterator.hasNext()){
       if(iterator.next().equals("b")){
           iterator.remove();
       }
   }
}

private static void fun3() {
        // 创建一个集合 按学生年龄进行排序
        ArrayList<Student> arrayList = new ArrayList<>();
        arrayList.add(new Student("a", 13));
        arrayList.add(new Student("b", 15));
        arrayList.add(new Student("c", 17));
        arrayList.add(new Student("d", 11));
        arrayList.add(new Student("e", 10));

        for (int i = 0; i < arrayList.size() - 1; i++) {
            for (int j = 0; j < arrayList.size() - 1 - i; j++) {
                // 比较年龄
                Student s1 = arrayList.get(j);
                Student s2 = arrayList.get(j + 1);
                if (s1.getAge() > s2.getAge()) {
                    // 交换在集合中的位置 set（index）
                    // set(int index ,Object obj)
                    arrayList.set(j + 1, s1);
                    arrayList.set(j, s2);

                }
            }

        }
        System.out.println(arrayList);
    }

按姓名进行排序

public static void sortByname(ArrayList<Student> arrayList) {
        for (int i = 0; i < arrayList.size() - 1; i++) {
            for (int j = 0; j < arrayList.size() - 1 - i; j++) {
                // 获取学生
                Student s1 = arrayList.get(j);
                Student s2 = arrayList.get(j + 1);
                // 比较姓名
                if (s1.getName().compareTo(s2.getName()) < 0) {
                    // 换位
                    Collections.swap(arrayList, j, j + 1);
                }
            }
        }