Java语法-集合

Java语法

Day19

晨考

Collections工具类

/*
Collection  集合工具类   此类中的方法全部为静态方法   此类种提供了用于操作集合的各种方法

swap(List<?> list,int i,int j)  交换指定位置的集合中的元素
sort(List<T> list,Comparator<? super T> c) 根据指定的比较器引起的顺序对指定的列表进行排序
reverse(List<?> list)  反转指定列表中元素的顺序。
replaceAll(List<T> list, T oldVal,T newVal) 将列表中一个指定值的所有出现替换为另一个
min(Collection<? extends T> coll)  根据其元素的  自然顺序返回给定集合的最小元素
fill(List<? super T> list, T obj)   用指定的元素代替指定列表的所有元素
binarySearch(List<? extends Comparable<? super T>> list,T key)  使用二叉搜索算法搜索指定对象的
*/
public class TestCollections {
    public static void main(String[] args){
        List<Integer> list = new ArrayList<>();
        
        list.add(125);
        list.add(896);
        list.add(666);
        list.add(258);
        list.add(321);
        
        Collections.sort(list);
        
        for(Integer integer : list){
            System.out.println("integer = " + integer);
        }
        
        System.out.println("-----------------------------------------");
        
        int index = Collection.binarySearch(list,666);
        
        System.out.println("index = " + index);
        System.out.println("-----------------------------------------");
     
        // 获取集合中最大元素  要求元素必须可以比较大小 即  实现Comparable接口  或者  定义Comparator实现类
        Integer max = Collections.max(list);
        
        System.out.println("max = " + max);
        
        System.out.println("-----------------------------------------");
        
        Integer min = Collections.min(list);
        System.out.println("min = " + min);
        
        System.out.println("-----------------------------------------");
        // 交换指定位置的元素
        Collections.swap(list,0,3);
        
        for(Integer integer : list){
            System.out.println("integer = " + integer);
        }
        
        System.out.println("-----------------------------------------");
        // 2使用指定元素填充集合
        Collections.fill(list,999);
        
        for(Integer integer : list){
            System.out.println("integer = " + integer);
        }
        
    }
}

泛型

/*
泛型： 用于统一数据类型

泛型可以使用的位置：类、接口、形参、返回值、属性

自定义泛型，如何书写(泛型的名称可以使用任何单词 字母 大小写都可以 但是我们只推荐使用一些有公认的含义的一些大写字母)

K    key      键
V    Value		值
T    Type		类型
E	Element		元素
R	Return		返回值
P	Parameter	参数
N	Number		数值  表示范围为Number及其子类


泛型初始化的时机：
1.类声明的泛型   是随着当前类创建对象初始化
2.接口声明的泛型  是随着实现类实现接口的初始化
*/
public class TestGenericType {
    
}

class A<T>{
    public void m1(T t){
        System.out.println("t = " + t);
    }
    
    public T m2(){
        return null;
    }
}

class TestA{
    public static void main(String[] args){
        A a1 = new A();
        a1.m1("abc");
        System.out.println(a1.m2());
        
        
        A<Integer> a2 = new A<Integer>();
        a2.m1(100);
        System.out.println(a2.m2());
        
        A<Double> a3 = new A<Double>();
        a3.m1(100.5);
        System.out.println(a3.m2());
        
    }
}

interface C<R,P>{
    R m1(P p);
}

class C1 implements C<Boolean,String>{
    @Override
    public Boolean m1(String s){
        return "abc".startsWith("a");
    }
}

class C2 implements C<Double,String>{
    @Override
    public Double m1(String s){
        return Double.parseDouble(s);
    }
}

class TestC{
    public static void main(String[] args){
        C1 c1 = new C1();
        System.out.println(c1.m1("abc"));
        
        C2 c2 = new C2();
        System.out.println(c2.m1("123"));
    }
}
class Animal{}
class Pet extends Animal{}
class Dog extends Pet{}
class Cat extends Pet{}

class TestPet{
    public static void m1(List<Pet> list){}
    
    // 泛型是不存在类型自动提升 
    // 要求形参为Pet类型  或者  Pet类的任意子类类型
    // ? extends 父类  :  表示泛型可以为父类  以及  父类的任何子类类型
    // Pet类的父类可以吗？
    public static void m2(List<? extends Pet> list){}
    
    /*
    要求：泛型为Dog  以及 Dog类的任何父类
    ? super  子类： 表示反省可以为子类  以及  任何子类的父类
    表示设置泛型的下限  没有上限
    */
    public static void main(String[] args){
        Vector<Pet> list1 = new Vector();
        ArrayList<Pet> list2 = new ArrayList<>();
        LinkedList<Pet> list3 = new LinkedList<>();
        m1(list1);
        m1(list2);
        m1(list3);
        
        System.out.println("---------------------------------------");
        Vector<Cat> list4 = new Vector();
        ArrayList<Pet> list5 = new ArrayList<>();
        m2(list4);
        m2(list5);
        m1(list1);
        
        ArrayList<Animal> list6 = new ArrayList<>();
        m2(list6);
        
    }
}