JAVA道路day12

ジェネリック

一般的な定義

import java.util.ArrayList;
import java.util.Collection;

//泛型
/*
泛型：是JDK5中引入的特性，它提供了编译时类型安全检测机制，该机制允许在编译时检测到非法的类型，它的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

一提到参数，最熟悉的就是定义方法时有形参，调用方法时传递实参，那么参数化类型怎么解释呢？顾名思义，就是将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型，这种参数类型可以在类、方法和接口中，分别被成为泛型类、泛型接口、泛型方法

 泛型定义格式
 - <类型>:指定一直类型的格式，这里的类可以看作的形参
 - <类型1，类型2....>:指定多种类型的格式，多种类型之间用逗号隔开
 - 将来具体调用时候给的类型可以看出是实参，并且实参的类型只能是引用数据类型。
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建一个对象
        Collection c=new ArrayList();
        c.add(12);
        c.add("yang");
        for (Object o:c){
            System.out.println(o);
        }
    }
}

ジェネリッククラス

//泛型类
/*
定义格式：修饰符 class 类名<类型>{}

范例：
public class Generic<T>{}
 */
public class GenericClass {
    public static void main(String[] args) {
        Generic<String> g=new Generic();
        Generic<Integer> g1=new Generic();

        g.setT("String,");
        g1.setT(11);

        System.out.println(g.getT()+g1.getT());

    }
}
class Generic <T>{//定义一个泛型类
    private T t;

    public Generic() {
    }

    public Generic(T t) {
        this.t = t;
    }

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

一般的な方法

//泛型方法
/*
定义格式
 -格式：修饰符<类型> 返回值类型 方法名（类型 变量名）{}
 -范例：public<T> void show(T t){}
 */
public class GenericMethod {

    public static void main(String[] args) {
        Generic2 g=new Generic2();
        g.show("one");
        g.show(1);
        g.show(11.1);
    }

}

class Generic2{
    public<T> void show(T t){
        System.out.println(t);
        }
}

ジェネリックインターフェイス

カスタム汎用インタフェース

//泛型类实现泛型接口
public class GenericClass<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

インタフェースの実装クラス

//泛型类实现泛型接口
public class GenericClass<T> implements Generic<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

mainメソッド

//泛型接口
/*
定义格式：修饰符 interface 接口名<类型>{}
范例： public interface Generic<T>{}
 */
public class Test {
    public static void main(String[] args) {
        //创建对象
        Generic<String> g1=new GenericClass<>();
        Generic<Integer> g2=new GenericClass<>();

        //调用方法
        g1.show("one");
        g2.show(111);


    }
}

ワイルドカードタイプ

import java.util.ArrayList;
import java.util.List;

//类型通配符
/*
  类型通配符：<?>
      List<?>:表示元素位置类型的List。它的元素可以匹配任意类型
      这种带通配符 List仅表示它是各种泛型List的父类，并不能把元素添加到其中
  类型通配符上限:<? extends 类型>
      List<? extends Number>:表示的是类型是Number或者其子类型
  类型通配符下线:<? super 类型>
      List<? super Number>:它表示的类型是Number或者其父类
 */
public class Demo01 {
    public static void main(String[] args) {
        //类型通配符
        List<?> list1=new ArrayList<Number>();
        List<?> list2=new ArrayList<String>();
        List<?> list3=new ArrayList<Integer>();
        List<?> list4=new ArrayList<Object>();

        // 类型通配符上限:<? extends 类型>
        List<? extends Number> list5=new ArrayList<Number>();
        //List<? extends Number> list6=new ArrayList<Object>();超过了上限
        List<? extends Number> list7=new ArrayList<Number>();

        //类型通配符下线:<? super 类型>
        List<? super Number> list8=new ArrayList<Number>();
        List<? super Number> list9=new ArrayList<Object>();
//        List<? super Number> list10=new ArrayList<Integer>();//超过了下限
        
    }
}

Mapクラス

地図コレクションの概要

import java.util.HashMap;
import java.util.Map;

/*
 Map集合概述
     Interface Map<K,V> K:键的类型  V：值的类型
     将键映射到值的对象；不能包含重复的键，每个键可以映射到最多一个值
     举例：学生的学号和姓名
             2020001 one
             2020002 two
             2020003 three
     创建Map集合的对象
         多态的方式
         具体的实现类HashMap
 */
public class Demo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<Integer,String> map=new HashMap<>();

        //添加元素
        map.put(2020001,"one");
        map.put(2020002,"two");
        map.put(2020003,"three");
        map.put(2020003,"threeII");

        //输出
        System.out.println(map);
    }
}

フィーチャーマップの基本セット

import java.util.HashMap;
import java.util.Map;

//Map集合的基本功能
/*
1.V put(K key,V value)  添加元素
2.V remove(Object Key)  根据键删除键值对应元素
3.void clear() 移除所有的键对应值
4.boolean containsKey(Object Key) 判断集合是否包含指定的键
5.boolean isEmpty() 判断集合是否为空
6.int size() 集合的长度，也就是集合中键值对的个数
 */
public class Demo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<Integer,String> map=new HashMap<>();

        //添加元素
        map.put(001,"yang");
        map.put(002,"sheng");
        map.put(003,"jie");

//        map.remove(001);

//        map.clear();

//        System.out.println(map.containsKey(001));

//        System.out.println(map.containsValue("sheng"));

        System.out.println("集合的长度："+map.size());
        //输出集合
        System.out.println(map);
    }
}

地図は、関数のコレクションを取得します。

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

//Map集合的获取功能
/*
1.V get (Object key) 根据键获取值
2.Set<K> keySet() 获取所有键的集合
3.Collection<V> values() 获取所有值的集合
4.Set<Map.Entry<K,V> entrySet() 获取所有键值对对象的集合(以后学习)
 */
public class Demo03 {
    public static void main(String[] args) {
        //创建一个集合对象
        Map<Integer,String> map=new HashMap<>();

        //给集合添加元素
        map.put(1,"one");
        map.put(2,"two");
        map.put(3,"three");

        //V get (Object key) 根据键获取值
        System.out.println(map.get(1));
        System.out.println(map.get(2));
        System.out.println(map.get(3));

        //Set<K> keySet() 获取所有键的集合
        Set<Integer> integers = map.keySet();
        System.out.println(integers);

        //Collection<V> values() 获取所有值的集合
        Collection<String> values = map.values();
        System.out.println(values);
    }
}

トラバーサル地図コレクション（A）

import java.util.HashMap;
import java.util.Map;

//Map集合遍历的方式（一）
/*
1.得到所有主键的集合，用keySet()方法
2.用增强for遍历
3.用主键找对应的值，用get(Object key)
 */
public class Demo04 {
    public static void main(String[] args) {
        //创建一个map集合
        Map<String,String> map=new HashMap<>();

        //给map集合添加元素
        map.put("one","ONE");
        map.put("two","TWO");
        map.put("three","THREE");

        //遍历所有元素
        for (String s:map.keySet()){
            System.out.println(s+map.get(s));
        }
    }
}

地図コレクショントラバーサル（B）

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import static javafx.scene.input.KeyCode.M;

//Map集合的遍历方式二
/*转换为Map集合中的操作
1.获取所有键值对象的集合
    Set<Map.Entry<K,V>> entrySet();获取所有键值对象的集合
2.遍历键值对对象的集合，得到每一个键值对的对象
    用增强for实现，得到每一个Map.Entry
3.根据键值对对象获取键和值
    用getKey()得到键
    用getValue()得到值
 */
public class Demo05 {
    public static void main(String[] args) {
        //创建一个Map集合
        Map<String,String> map=new HashMap<>();

        //添加元素
        map.put("one","ONE");
        map.put("two","TWO");
        map.put("three","THREE");

        //获取键值对对象的集合
        Set<Map.Entry<String, String>> entries = map.entrySet();
        //用增强for遍历
        for (Map.Entry<String, String> me:entries){
            System.out.println(me.getKey()+","+me.getValue());
        }

    }
}

ケース1

mainメソッド

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

//案例：HashMap集合存储学生对象并遍历
/*
需求：创建一个HashMap集合，键是学生(String),值是学生对象(Student)存储三个键值对元素
 */
public class Test {
    public static void main(String[] args) {
        //创建一个HashMap集合
        HashMap<String,Student> hashMap=new HashMap<>();

        //创建学生对象
        Student s1 = new Student("one.name", 1);
        Student s2 = new Student("two.name", 2);
        Student s3 = new Student("three.name", 3);

        //把学生对象添加进元素
        hashMap.put("001",s1);
        hashMap.put("002",s2);
        hashMap.put("003",s3);

        //用entrySet方法遍历
        Set<Map.Entry<String, Student>> entries = hashMap.entrySet();
        for (Map.Entry<String,Student> me:entries){
            System.out.println(me.getKey()+","+me.getValue().getName()+","+me.getValue().getAge());
        }

        //用keySet()方法遍历
        Set<String> keySet = hashMap.keySet();
        for (String s:keySet){
            System.out.println(s+","+hashMap.get(s).getName()+","+hashMap.get(s).getAge());
        }
    }
}

学生カテゴリ

//自定义学生类
public class Student  {
    private String name;
    private int age;

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

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

ケース2

mainメソッド

//案例：HashMap集合才能出学生对象并遍历
/*
需求：创建一个HashMap集合，键(Student)是学生对象，值(String)是居住地,存储多个键值对元素并遍历。
     要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象。
 */

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class Test {
    public static void main(String[] args) {
        //创建一个HashMap集合
        HashMap<Student,String> hm=new HashMap<>();

        //创建学生对象
        Student s1=new Student("one.name",11);
        Student s2=new Student("two.name",22);
        Student s3=new Student("three.name",33);
        Student s4=new Student("three.name",33);

        //添加学生对象到元素中去
        //以为要判断主键是否相同，所以在学术类中重写hashCode()和equals()方法
        hm.put(s1,"one.address");
        hm.put(s2,"two.address");
        hm.put(s3,"three.address");
        hm.put(s4,"four.address");

        //用keySet()遍历
        Set<Student> ks = hm.keySet();
        for (Student s:ks){
            System.out.println(s.getName()+","+s.getAge()+","+hm.get(s));
        }

        System.out.println("==============");
        //用entrySet()存储键值对对象进行遍历
        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> me:entries){
            Student s=me.getKey();
            String s5=me.getValue();
            System.out.println(s.getName()+","+s.getAge()+","+s5);
        }
    }
}

学生カテゴリ

//自定义学生类
public class Student {
    private String name;
    private int age;

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }

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

ケース3

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/*案例：ArrayList集合存储HashMap元素并遍历
需求：创建一个ArrayList集合，存储三个元素，每一个都是HashMap，每一个HashMap的键和值都是String，并遍历
 */
public class Test {
    public static void main(String[] args) {
        //创建一个ArrayList集合
        ArrayList<HashMap<String,String>> array=new ArrayList();
        array.size();

        //创建三个HashMap元素
        HashMap<String,String> hm1=new HashMap<>();
        HashMap<String,String> hm2=new HashMap<>();
        HashMap<String,String> hm3=new HashMap<>();
        hm1.put("111","111");
        hm1.put("222","111");
        hm1.put("333","111");

        hm2.put("111","111");
        hm2.put("222","111");
        hm2.put("333","111");

        hm3.put("111","111");
        hm3.put("222","111");
        hm3.put("33aaa3","111");
        
        //放入集合中
        array.add(hm1);
        array.add(hm2);
        array.add(hm3);

        //遍历需要两层
        for (HashMap<String,String> hm:array){
            Set<Map.Entry<String, String>> entries = hm.entrySet();
            for (Map.Entry<String, String> me:entries){
                String key = me.getKey();
                String value = me.getValue();
                System.out.println(key+value);
            }
            System.out.println("==========");
        }


    }
}

ケース4

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

//案例4:HashMap集合存储ArrayList元素并遍历
//需求：创建一个HashMap集合，存储三个键值对元素，每一个键值对元素的键是String，值是ArrayList
public class Test {
    public static void main(String[] args) {
        //创建一个HashMap集合对象
        HashMap<String, ArrayList<String>> hm=new HashMap<>();

        //创建ArrayList对象作为元素
        ArrayList<String> a1=new ArrayList();
        ArrayList<String> a2=new ArrayList();
        ArrayList<String> a3=new ArrayList();
        a1.add("aaaa");
        a1.add("bbbb");
        a1.add("cccc");
        a2.add("dddd");
        a2.add("eeee");
        a2.add("ffff");
        a3.add("ggg");
        a3.add("hhhh");
        a3.add("iiii");

        //把ArrayList添加到HashMap
        hm.put("111111",a1);
        hm.put("222222",a2);
        hm.put("333333",a3);

        //遍历
        //创建键值对对象集合
        Set<Map.Entry<String, ArrayList<String>>> entries = hm.entrySet();

        for (Map.Entry<String, ArrayList<String>> me:entries){
            ArrayList<String> value = me.getValue();
            String key = me.getKey();
            System.out.println();
            System.out.print(key+" ");
            for (String s:value){
                System.out.print(s+" ");
            }
            System.out.println();

        }

    }
}