java学习笔记07-泛型

泛型
1.如果我们使用了泛型，就可以明确集合中到底放什么样的数据类型
2.定义泛型的语法：泛型可以使用在 类，接口 方法 <引用类型，引用类型>
3.泛型的好处：将问题提前到了编译期，避免了向下转型。
4.注意：泛型只在编译期有效，在运行期就擦除了。
5.集合明确了泛型的具体类型，那么这个集合只能存储这种类型

ArrayList<String> list1 = new ArrayList<>();
list1.add("abc");

ArrayList<Object> list2 = new ArrayList<>();
list2.add(300);
list2.add("abc");

ArrayList<Student> list = new ArrayList<>();
list.add(new Student("zhansgan",78));//里面的对象已经被强转类型
Student student1 = new Student("zhansgan",78);
list.add(student1);

缺少没写
1.泛型在类上
创建对象时候明确

public class MyTest {
    public static void main(String[] args) {
        //设计一个类，既要扩展性，也不想向下转型。
        //设计一个泛型类，给类加上泛型
        //class A<T>{}
        //泛型机制：是JDK1.5引入的，是一种将数据类型明确工作，推迟到创建对象，或调用方法时，再去明确的一种机制。
        MyDem<String> myDem = new MyDem<>();
        myDem.setObj("abc");
        String obj = myDem.getObj();
        System.out.println(obj);
        
        MyDem<Integer> integerMyDem = new MyDem<>();
        integerMyDem.setObj(200);
        Integer obj1 = integerMyDem.getObj();
        new ArrayList<Integer>();
    }
}
class MyDem<T> { //T 泛型
    private T obj;
    public T getObj() {
        return obj;
    }
    public void setObj(T obj) {
        this.obj = obj;
    }
}

也可以是多个泛型

public class MyHaHa<R,P>{
    private R r;
    private P p;

}
public class MyTest {
    public static void main(String[] args) {
        MyHaHa<Integer, String> integerStringMyHaHa = new MyHaHa<>();
       // integerStringMyHaHa.set("string");

        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(100);
        integers.add(100);
        integers.forEach(new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        });
    }
}

2.泛型在接口上
在子类继承的时候可以进行具体泛型实现
3.泛型在方法上
方法上的泛型在调用方法时明确，传给什么参数就明确为什么类型

增强for循环

for(荣启明 当前变量名：容器名)
快捷键是 容器名.for
注明：这个for循环底层用的是迭代器迭代，不能进行操作，只能进行打印操作

在这里插入代码片

可变参数
一次可以接收多个参数,其本质是一个数组
如果一个方法有普通参数也有可变参数，可变参数放到后面。add（int a,int … b）

int sum = add(a，b);
int sum1 = add(a,c,s);
public int add(int ... num){
for(int i:num){
sum+=i;
}
}

数组和集合的互相转换
1.集合转数组

Object[] objects = new ArrayList<Integer>().toArray();

2.数组转集合
通过这个方法转换过来的集合 只能查询和修改，不能增删，转换过来的长度不可变

List<Object> objects = Arrays.asList();

2.1.注：如果你给该方法，传入的是一个引用类型数组，那么他会取出数组中的元素，放到集合中
索引方式：

object.get(1);

2.2.注：假如你传入两个以上的数组，他是把数组对象作为元素，放到集合中

List<Integer[]> integers4 = Arrays.asList(integers, integers2);

索引方式：

Integer integer = integers4.get(0)[0];//第一个数组的第几个数

2.3.当你传人一个基本类型数组，那么转换成集合，集合放到是数组对象
ste:元素唯一
HashSet：顶层数据结构是哈希表，元素唯一，且无序。
元素唯一是开 元素重写hashCode()和equals()方法来保证的，如果元素不重写则无法保证元素唯一。

HashSet<String> hashSet = new HashSet<>();
hashSet.add("林青霞");
hashSet.add("林青霞");//存不进去，因为元素唯一

LinkHsahSet，可以保证元素唯一 而且有序

TreeSet：底层数据结果是二叉树，元素唯一，可以对元素进行排序，排序方式分两种，
1.自然排序：要使用午餐构造，对元素有要求，元素必须实现一个 comparable接口，重写其中的comparaTo()方法，根据此方法，返回值是正负决定在树结构中左右。

TreeSet<Student> set = new TreeSet<>();
treeSet.add(20);
treeSet.add(18);//直接排序
set.add(new Student("杨超越asdfasfd", 20));//Studen类必须元素必须实现一个 comparable接口，重写其中的comparaTo()方法,在添加元素的时候 已经后台调用方法排序好了。
set.add(new Student("杨超越2", 20));
class Student implements Comparable<Student>{
public int compareTo(Student o) {
.............
return 正值or负值; //根据 返回值的 正 负 0 来决定元素的左右顺序
}
}

2.比较器 排序：使用有残构造的时候就使用比较器排序

map集合
map用来存储键值的数据
Map接口：
Hashmap

HashMap<String, String> stringStringHashMap = new HashMap<>();
stringStringHashMap.put("文章","马伊琍")

注意：键相同，之后被后面的覆盖