Java学习笔记Day2

集合2

1.contains方法

/*
contains方法
结论:存放在集合中的类型重写了equals方法
 */

import java.util.Collection;
import java.util.LinkedList;
import java.util.Objects;

public class Test01 {
    public static void main(String[] args) {
        Collection c = new LinkedList();
        c.add(new String("abc"));
        c.add(new String("def"));
        System.out.println("元素个数:"+c.size());
        String s = new String("abc");
        System.out.println(c.contains(s));
        //底层调用equals()方法判断，比较的是内容，故返回true
        User u1 = new User("jack");
        User u2 = new User("jack");
        c.add(u1);
        System.out.println(c.contains(u2));
        //没有重写equals()时，返回false
        //重写equals()时，返回true
    }
}
class User{
    private String name;

    public User() {
    }
    public User(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || !(o instanceof User)) return false;
        if(o == this) return true;//内存地址相同
        User user = (User) o;
        return user.name.equals(this.name);//比较内容
    }
}

2.remove方法

• 同contains方法，调用重写后的equals方法，删除内容相同的数据

3.List接口中常用方法

/*
List接口常用方法
void add(int index,E element)
E get(int index)
int indexOf(Object o)
int lastIndexOf(Object o)
E remove(int index)
 */
public class Test02 {
    public static void main(String[] args) {
        List l = new ArrayList();
        l.add(1);
        l.add("hello");
        l.add('A');
        l.add("b");
        l.add('A');
        //效率比较低
        l.add(1,"sad");
        Iterator it = l.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        }
        System.out.println("---------------------");
        //根据下标获取元素
        System.out.println(l.get(2));
        System.out.println("---------------------");
        //获取指定对象第一次出现的索引
        System.out.println(l.indexOf("b"));
        System.out.println("---------------------");
        //获取指定对象最后一次出现的索引
        System.out.println(l.lastIndexOf('A'));
        System.out.println("---------------------");
        //删除指定位置的元素
        System.out.println(l.remove(0));
        System.out.println(l.size());
        //修改指定位置的元素
        l.set(2,"world");
        for (int i = 0; i < l.size(); i++) {
            System.out.println(l.get(i));
        }
    }
}

4.ArrayList

1.ArrayList集合初始化容量是10
2.底层是Object类型的数组
3.创建对象时可指定容量
4.ArrayList集合扩容:扩容为原容量的1.5倍
5.在jdk1.8中，调用空构造器时，底层数组初始化为空数组，调用add后，容量为10

5.Vector

1. 底层是Object类型数组
2. 调用构造方法时，初始化数组长度为10
3. 扩容长度为原来的2倍
4. 线程安全，效率低

6.泛型

6.1 什么是泛型

• 泛型相当于标签，形式为<>
• 设置集合的类型为同一种类型
• 泛型的数据类型为引用数据类型
• A和B是子类和父类关系，但G和G不存在继承关系，是并列关系，因为底层都是Object类型，泛型只在编译阶段进行了限制

6.2 泛型实例

public class Test01 {
    public static void main(String[] args) {
        //创建一个ArrayList集合，存入学生成绩
        ArrayList<Integer> al = new ArrayList<>();
        al.add(99);
        al.add(95);
        al.add(100);
        al.add(90);
        //遍历集合
        for(Integer i:al){
            System.out.println(i);
        }
    }
}

6.3自定义泛型

package com.shownshy.Day4;

import java.util.ArrayList;

/*泛型类
1.<>里面是参数类型，这个类型现在是不确定的，确定的是一定为引用数据类型
2.泛型类可以定义多个数据类型
 */
public class Test02 <E>{
    int age;
    String name;
    E sex;
    public void a(E n){

    }
}
//多种参数类型的泛型类
class Test05<A,B,C>{
    A name;
    B age;
    C sex;
    //泛型类的构造器
    public Test05(A name, B age, C sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    //不同的泛型的引用类型不可以相互赋值
    public void b(){
        ArrayList<String> a1 = null;
        ArrayList<Integer> a2 = null;
        //a1 = a2;错误
    }
    //不能存在静态方法
    /*public static int c(A a){
        return 10;
    }*/
}
class Test{
    public static void main(String[] args) {
        //实例化时不指定数据类型,则为Object类型
        Test02 t =new Test02();
        t.a(18);
        t.a("hello");
        //实例化时指定数据类型
        Test02<String> t2 = new Test02<>();
        t2.sex = "男";
        t2.a("hello");
        //继承时指定父类泛型时，子类就不需要指定泛型了
        Test03 t3 = new Test03();
        t3.a(100);
        //继承时不指定父类泛型时，类型在子类创建实例化对象时确定
        Test04<String> t4 = new Test04<>();
        t4.a("hhhh");
        t4.sex = "女";

    }
}
//继承时指定父类泛型
class Test03 extends Test02<Integer>{

}
//继承时不指定父类泛型
class Test04<E> extends Test02<E>{

}

6.4泛型方法

/*
1.什么是泛型方法
这个方法的泛型的参数类型要和当前类的泛型无关
2.泛型方法是否可以是静态方法？可以
 */
public class Test06<E> {
    //不是泛型方法
    public  void a(E e){

    }
    //是泛型方法
    public static <T> void b(T t){

    }
    //错误，重复定义，参数属于并列关系
    /*public void c(List<Object> list){
        
    }
    public void c(List<String> list){

    }
    public void c(List<Integer> list){

    }*/
}

class demo{
    public static void main(String[] args) {
        Test06<String> t = new Test06<>();
        t.a("abc");
        t.b("cdcd");//T的类型是在调用方法时确定的
        t.b(656);
    }
}

6.5通配符

public class Test07 {
    public static void main(String[] args) {
        List<Object> list1 = new ArrayList<>();
        List<String> list2 = new ArrayList<>();
        List<Integer> list3 = new ArrayList<>();
        List<?> list = null;//通配符
        list = list1;
        list = list2;
        list = list3;
    }
}

6.6泛型受限

public class Test08 {
    public static void main(String[] args) {
        List<Object> a = new ArrayList<>();
        List<Person> b = new ArrayList<>();
        List<Student> c = new ArrayList<>();
        List<? extends Person> list1 = null;
        /*1.受限上限
        List<? extends Person>相当于是List<Person>的父类
         */
       /* list1 = a;
        list1 = b;
        list1 = c;*/
        //泛型下限
        List<? super Person> list2 = null;
        list2 = a;
        list2 = b;
        //list2 = c;
    }