Day14

泛型

2.使用具体的泛型
语法: List<Student(确定类型)> list = new ArrayList();
前后的泛型都必须一样
泛型的类型 不能是基本数据类型 必须是引用数据类型
避免在使用的时候 反复需要强制类型转

shiyan1类

public class Shiyan1<T>implements Shiyan1Inner<String > {
    List<T> list=new ArrayList<>();

    public  void play2(T t){
        list.add(t);
    }
    public  T play3(int d){
        return  list.get(d);
    }

    public T play1(T t){
        return t;
    }

    @Override
    public void play66(String s) {
        System.out.println(s);
    }
}

接口泛型

public interface Shiyan1Inner <T> {
    void play66(T t);
}

测试

public class Shiyan1Test1 {
    public static void main(String[] args) {
    Shiyan1<String > s=new Shiyan1();
        System.out.println(s.play1("6666"));
        Shiyan1<Integer> s1=new Shiyan1<Integer>();
        System.out.println(s1.play1(238));
        s.play2("bangde");
        System.out.println(s.play3(0));
        s.play66("sidji");
}
}

泛型的通配符
1.泛型的通配符就是? ? 可以表示任意的数据类型 通配符一般是在方法传递的时候使用,集合实例化的时候不能使用通配符

set集合

2.特点：
无序：存与取的顺序不一样
集合中的元素不能重复
set是没有索引 不能使用普通的for循环
set 集合没有特别的方法 都是使用Collection的方法
set 接口的实现类
set 集合四种遍历方式
1.不使用泛型进行遍历(使用数组 >把集合转换为数组)
Object[] toArray()
2.使用泛型的进行遍历(使用数组> 把集合转换为数组)
T T[] 数组名= toArray(T[size()] )
3.使用迭代器来进行遍历
4.使用增强for循环
语法：
for(数据类型 变量名 : 需要遍历数组以及集合) {
执行的循环操作
}

public class Shiyan3 {
    public static void main(String[] args) {
        Set<String> s =new HashSet<>();
        s.add("ggg");
        s.add("jkhk");
        s.add("sda");

        Object[] objects=s.toArray();
        for (Object o:objects){
            System.out.println(o);
        }

        for (String s1:s){
            System.out.println(s1);
        }

        String[] strings=s.toArray(new String[s.size()]);
        for (String a:strings){
            System.out.println(a);
        }
        Iterator<String > iterator=s.iterator();
        while (iterator.hasNext()){
            System.out.println(iterator.next());
        }
    }
}

HashSet
set集合在添加数据的时候 如何判断数据是否重复 先用hashCode() 再用 equals() 方法 。
LinkedHashSet
1.LinkedHashSet 是HashSet的子类
2.LinkedHashSet 是以hash表与链表来实现 哈希表和双链接列表
3.特点： 有序 不可以重复

public class Shiyan4 {
    public static void main(String[] args) {
        Scanner input =new Scanner(System.in);
        String  s=input.nextLine();
        char[] ch=s.toCharArray();
        HashSet<Character> hashSet=new LinkedHashSet<>();
        for (Character a:ch){
            hashSet.add(a);
        }
        System.out.println(hashSet);
    }
}

Map

Map常用的方法
V put(K key,V value) 向map集合中以键值对来存数据 也可以修改
void clear() ==> 将map集合进行清空
boolean isEmpty() ==>判断map集合中是否存在元素
V get(Object key) ==> 根据键来获取值
V remove(Object key) 根据键来删除
boolean containsKey(Object key) 判断键是否存在
boolean containsValue(Object value) 判断值是否存在
int size() 获取集合的长度

map两种遍历方式

第一种 将键值放到集合中
Set keySet() 获取map中所以的键
Collection values() 获取所以的值
Set<Map.Entry<K,V>> entrySet() ==> 用于来遍历map集合

1.获取map集合中所以的键 keySet() ==>Set集合
2.遍历 增强for循环 或者是迭代器
3.通过键来获取值 get()

第二种 将map化为对象 放到集合中

Set<Map.Entry<K,V>> entrySet()
Set 是存的每一组数据的对象 Map.Entry<K,V> 数据类型
==> getkey() 获取键 getvalue() ==> 获取值
增强for循环 或者是迭代器

public class Shiyan5 {
    public static void main(String[] args) {
        Map<String,String> map=new HashMap();
        map.put("jsgd","shgf");
        map.put("ouidh","sjhd");
        System.out.println(map.isEmpty());
        System.out.println(map.get("jsgd"));
        map.remove("jsgd");
        
        Set<String> set=map.keySet();
        for (String c: set){
            System.out.println(map.get(c));
        }
        Iterator<String> iterato=set.iterator();
        while (iterato.hasNext()){
            System.out.println(map.get(iterato.next()));
        }

        Set<Map.Entry<String,String>> s1=map.entrySet();
        for (Map.Entry<String,String> b: s1){
            System.out.println(b.getKey()+"\t"+b.getValue());
        }

        Iterator<Map.Entry<String,String>> iterato1=s1.iterator();
        while (iterato1.hasNext()){
            Map.Entry<String,String> in=iterato1.next();
            System.out.println(in.getKey()+"\t"+in.getValue());
        }

    }
}