javaSE21/9/20

Posted 2021-09-20 想吃坚果

泛型

• 其本质是参数类型，把类型当作参数传递
• 作用
  1）提高代码的重用性
  2）防止类型转换异常，提高代码的安全性
• 泛型只能是引用类型
• 不同的泛型对象不能相互赋值

泛型类

/**
 * 泛型类
 * 语法：类名<T >  T表示引用类型，可写多个，要用逗号隔开
 */
public class MyGeneric<T> {
    //使用泛型T
    // T可以创建变量
    T t;
    //添加方法，泛型可以作为方法的参数
    public  void show(T t){
        System.out.println(t);
    }
    //泛型作为方法的返回值
    public T getT() {
        return t;
    }
}

public class Test {
    public static void main(String[] args){
        //使用泛型类创建对象
        MyGeneric<String> myGeneric = new MyGeneric<>();
        myGeneric.t ="张三";
        myGeneric.show("张三是好人");
        String str = myGeneric.getT();
        MyGeneric<Integer> myGeneric1 = new MyGeneric<>();
        myGeneric1.t = 100;
        myGeneric1.show(20);
        Integer in = myGeneric1.getT();
    }
}

泛型接口

/**
 * 泛型接口
 * 语法：接口名<T>
 */
public interface MyInterface<T> {
    String name = "张三";
    T server (T t);//抽象方法
}

public class MyInterfaceImpl implements MyInterface<String> {
    @Override
    public String server(String t) {
        System.out.println(t);
        return t;
    }
}

public class Test {
    public static void main(String[] args){
        MyInterfaceImpl im = new MyInterfaceImpl();
        im.server("实现类");
    }
}

泛型方法

/**
 * 泛型方法
 * 语法：<T> 返回值类型
 */
public class MyGenericMethod {
    //泛型方法
    public <T> void show(T t){//只能用在本方法中
        System.out.println(t);
    }
}

public class Test {
    public static void main(String[] args){
        MyGenericMethod myg = new MyGenericMethod();
        myg.show(20);//泛型方法的类型由传递的数据决定
        myg.show("张三");
    }
}

泛型集合

• **概念：参数化类型，类型安全的集合，强制集合元素的类型必须一致 **

public class Test {
    public static void main(String[] args){
        ArrayList<String> arrayList = new ArrayList<String>();
        arrayList.add("苹果");
        arrayList.add("桔子");
        //arrayList.add(20); 会报错，因为已经将ArrayList用String泛型约束
        for (String str: arrayList) {
            System.out.println(str);
        }

    }
}

Set子接口

• 特点：无序，无下标，元素不可重复
• 方法：全部继承自Colletion中的方法

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class Test {
    public static  void main(String[] args){
        Set<String> set = new HashSet<>();
        //添加
        set.add("草莓");
        set.add("苹果");
        set.add("香蕉");
        set.add("桔子");
        System.out.println(set.size());
        System.out.println(set.toString());
        //删除
        set.remove("苹果");
        System.out.println(set.size());
        System.out.println(set.toString());
        //遍历
        Iterator<String> it = set.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
        //判断
        set.contains("苹果");
    }
}

Set实现类

HashSet

• 基于HashSet计算元素存放位置
• 当存入的哈希码值相同时，会调用equals进行确认，如结果为true，则拒绝后者进入
• 存储结构是哈希表（数组+链表+红黑树）

public class Person {
    private String name ;
    private int age,phone;

    public Person() {
    }

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

    @Override
    public String toString() {
        return name+":"+"年龄"+age+"电话"+phone;
    }

    @Override
    public int hashCode() {
        int n1 = this.name.hashCode();
        int n2  = age;
        int n3 = phone;
        return n1 + n2 + n3;
    }

    @Override
    public boolean equals(Object obj) {
        if (this==obj)
            return true;
        if (obj==null)
            return false;
        if (obj instanceof Person){
            Person p = (Person) obj;
            if (this.name.equals(p.getName())&&this.age==p.getAge()&&this.phone==p.phone){
                return true;
            }
        }
        return false;
    }

    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;
    }

    public int getPhone() {
        return phone;
    }

    public void setPhone(int phone) {
        this.phone = phone;
    }
}

public class Test {
    public static  void main(String[] args){
        HashSet<Person> persons = new HashSet<>();
        Person p1 = new Person("张丽",19,123456789);
        Person p2 = new Person("曹明",20,132456789);
        Person p3 = new Person("李图图",19,142456789);
        //添加
        persons.add(p1);
        persons.add(p2);
        persons.add(p3);
        /*
        new 一个与p1一样的Person，添加成功
        想让集合认定俩组Person是同一个，需要对hashCode和equals方法进行重写
        重写后相同元素加不进来了
         */

        persons.add(new Person("张丽",19,123456789));
        System.out.println(persons.toString());
        //遍历
        Iterator it = persons.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}