19、泛型_泛型语法任意大写字符-CSDN博客

本文链接：https://blog.csdn.net/ao_long/article/details/124651498

一、HashMap

Map接口的实现，数据结构为hash表，允许使用null键与null值，在多线程下不安全，默认容量为16
为HashSet的区别：都是采用hash表进行存储的，但HashSet的底层是使用HashMap进行存储的，HashMap的数据结构针对的是键，HashSet的数据结构针对的是元素
常有方法：继承Map接口的方法

二、LinkedHashMap

由哈希表和链接列表实现，具有可预知的迭代顺序，即有序，此实现类在多线程下不安全

三、泛型

在定义集合时，不确定其类型时，可以使用泛型，泛型就是一个变量，可以接受数据类型
在实例化集合时可以确定泛型，泛型只能使用引用数据类型，jdk1.7之后出现了菱形的泛型，其后面的泛型可以省略，可进行自动推断
好处：避免强制类型转换，将运行时的异常提前到了编译期间
泛型的符号可以是任意大写字面，如：E/V/K/W

3.1、定义泛型类

语法：

访问修饰符 class 类名<泛型>{

类中所有成员都可以使用泛型

}
案例

package com.la.demo01;
import java.util.ArrayList;
public class TestGeneric<T> {
    private ArrayList<T> list=new ArrayList<T>();
    public void add(T t){
        list.add(t);
    }
    public void add(int index,T t){
        list.add(index,t);
    }
    public T get(int index){
        return list.get(index);

    }
}

package com.la.demo01;
public class Test {
    public static void main(String[] args) {
        TestGeneric<String> stringTestGeneric = new TestGeneric<>();
        stringTestGeneric.add("小黑");
        stringTestGeneric.add(1,"小白");
        System.out.println(stringTestGeneric.get(0));
        System.out.println(stringTestGeneric.get(1));
    }
}

3.2、定义泛型方法

语法

访问修饰符 <泛型> 返回值类型方法名(参数列表){

方法体；

return 返回值；

}
说明：可以给普通成员方法加泛型，也可以给静态方法加泛型
注：静态方法方法不可以使用类的泛型，因为静态资源优先于类先加载
案例

package com.la.demo01;
public class TestGeneric01 {
    public static<T> T[] change(T[] t,int index1,int index2){
        T temp=t[index1];
        t[index1]=t[index2];
        t[index2]=temp;
        return t;
    }
}

package com.la.demo01;
import java.util.Arrays;
public class Test1 {
    public static void main(String[] args) {
        System.out.println(Arrays.toString(TestGeneric01.change(new String[]{"xiaoming", "xiaohei"}, 0, 1)));
    }
}

3.3、定义泛型接口

体现1：实现类确定其泛型

public interface Iterator<E>{
     E next();
}

public final class Scanner implements Iterator<String>{
    public String next();
}

体现2：实现类不确定其泛型

public interface List<E>{
    boolean add(E e);
}

public class ArrayList<E> implements List<E>{
    public boolean add(E e);
}

3.4、泛型的通配符

泛型的统配符可以表示任意的数据类型，通配符为？
通配符一般作为方法的参数来实现
？extends E E本身或者其子类；？super E E本身或者其父类

3.5、案例

package com.la.demo02;
public class Student {
    private int sno;
    private String name;
    private int age;
    public Student(int sno, String name, int age) {
        this.sno = sno;
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Student{" +
                "sno=" + sno +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

package com.la.demo02;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestMap {
    public static void main(String[] args) {
        HashMap<Integer,Student> javaMap=new HashMap<>();
        javaMap.put(1001,new Student(1001,"小红",20));
        javaMap.put(1002,new Student(1002,"小黑",20));
        HashMap<Integer,Student> webMap=new HashMap<>();
        webMap.put(1003,new Student(1003,"小光",20));
        webMap.put(1004,new Student(1004,"小明",20));
        HashMap<String,HashMap<Integer,Student>> totalMap=new HashMap<>();
        totalMap.put("java",javaMap);
        totalMap.put("web",webMap);
        Set<String> strings = totalMap.keySet();
        for (String string : strings) {
            System.out.println(string);
            HashMap<Integer, Student> integerStudentHashMap = totalMap.get(string);
            Set<Map.Entry<Integer, Student>> entries = integerStudentHashMap.entrySet();
            for (Map.Entry<Integer, Student> entry : entries) {
                System.out.println(entry.getValue());
            }
//            Set<Integer> integers = integerStudentHashMap.keySet();
//            for (Integer integer : integers) {
//                System.out.println(integerStudentHashMap.get(integer));
//            }
        }
        Iterator<String> iterator = strings.iterator();
        while (iterator.hasNext()){
            String next = iterator.next();
            System.out.println(next);
            HashMap<Integer, Student> integerStudentHashMap = totalMap.get(next);
            Set<Integer> integers = integerStudentHashMap.keySet();
            Iterator<Integer> iterator1 = integers.iterator();
            while (iterator1.hasNext()){
                System.out.println(integerStudentHashMap.get(iterator1.next()));
            }
        }
    }
}

四、集合工具类Collections

常用方法

方法名	描述
[binarySearch](…/…/java/util/Collections.html#binarySearch(java.util.List, T))(List<? extends Comparable<? super T>> list, T key)	使用二分搜索法搜索指定列表，以获得指定对象。
[copy](…/…/java/util/Collections.html#copy(java.util.List, java.util.List))(List<? super T> dest, List<? extends T> src	将所有元素从一个列表复制到另一个列表。
[fill](…/…/java/util/Collections.html#fill(java.util.List, T))(List<? super T> list, T obj)	使用指定元素替换指定列表中的所有元素
[max](…/…/java/util/Collections.html#max(java.util.Collection, java.util.Comparator))(Collection<? extends T> coll, Comparator<? super T> comp)	根据指定比较器产生的顺序，返回给定 collection 的最大元素
[min](…/…/java/util/Collections.html#min(java.util.Collection, java.util.Comparator))(Collection<? extends T> coll, Comparator<? super T> comp	根据指定比较器产生的顺序，返回给定 collection 的最小元素。
[replaceAll](…/…/java/util/Collections.html#replaceAll(java.util.List, T, T))(List list, T oldVal, T newVal)	使用另一个值替换列表中出现的所有某一指定值
reverse(List<?> list)	反转指定列表中元素的顺序。
shuffle(List<?> list)	使用默认随机源对指定列表进行置换
sort(List list)	根据元素的自然顺序对指定列表按升序进行排序
[swap](…/…/java/util/Collections.html#swap(java.util.List, int, int))(List<?> list, int i, int j)	在指定列表的指定位置处交换元素

斗地主游戏

package com.la.demo03;
import java.util.*;
public class PlayCard {
    public static void main(String[] args) {
        String[] colors={"♦","♣","♥","♠"};
        String[] nums={"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        HashMap<Integer,String> map=new HashMap<>();
        List<Integer> list=new ArrayList<>();
        int index=0;
        for (String num : nums) {
            for (String color : colors) {
                map.put(index,color+num);
                list.add(index);
                index++;
            }
        }
        map.put(index,"小王");
        list.add(index);
        index++;
        map.put(index,"大王");
        list.add(index);
        System.out.println(map.values());
        System.out.println(list);
        Collections.shuffle(list);
        System.out.println(list);
        TreeSet<Integer> one=new TreeSet<>();
        TreeSet<Integer> two=new TreeSet<>();
        TreeSet<Integer> three=new TreeSet<>();
        TreeSet<Integer> di=new TreeSet<>();
        for (int i = 0; i < list.size(); i++) {
            if (i>=list.size()-3){
                di.add(list.get(i));
            }else if (i%3==1){
                one.add(list.get(i));
            }else if (i%3==2){
                two.add(list.get(i));
            }else if (i%3==0){
                three.add(list.get(i));
            }
        }
        System.out.println(di);
        System.out.println(one);
        System.out.println(two);
        System.out.println(three);
        look("one",map,one);
        look("two",map,two);
        look("three",map,three);
    }
    public static void look(String name,HashMap<Integer,String> map,TreeSet<Integer> card){
        String cards=name+": ";
        Set<Map.Entry<Integer, String>> entries = map.entrySet();
        for (Integer integer : card) {
            for (Map.Entry<Integer, String> entry : entries) {
                if (integer==entry.getKey()){
                    cards += entry.getValue()+" ";
                }
            }
        }
        System.out.println(cards);
    }
}

五、练习

双色球

package com.la.demo05;
import java.util.*;
public class Boll {
    public static void main(String[] args) {
        ArrayList<String> nums1=new ArrayList<>();
        String no="";
        for (int i = 1; i <=33; i++) {
            nums1.add("红球"+i);
        }
        ArrayList<String> nums2=new ArrayList<>();
        for (int i = 1; i <=16; i++) {
            nums2.add("蓝球"+i);
        }
        Collections.shuffle(nums2);
        Collections.shuffle(nums1);
        for (int i = 0; i < 6; i++) {
            no+=nums1.get(i)+" ";
        }
        System.out.println(no+" "+nums2.get(0));
    }
}

统计字符串的字符数量

package com.la.demo05;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
public class CharCount {
    public static void main(String[] args) {
        ArrayList<String> list=new ArrayList<>();
        HashMap<Character, Integer> map = new HashMap<>();
        list.add("abc");
        list.add("bcd");
        list.add("dbf");
        for (String s : list) {
            char[] chars = s.toCharArray();
            System.out.println(Arrays.toString(chars));
            for (int i = 0; i < chars.length; i++) {
                if (map.containsKey(chars[i])){
                    map.put(chars[i],map.get(chars[i])+1);
                }else {
                    map.put(chars[i],1);
                }
            }
        }
        System.out.println(map);
    }
}

获取世界杯信息

package com.la.demo05;
import java.util.*;
public class NewContainsValue {
   static HashMap<String, List<Integer>> map = new HashMap<>();
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Scanner scanner = new Scanner(System.in);
        list.add(1958);
        list.add(1962);
        list.add(1970);
        list.add(1994);
        list.add(2002);
        map.put("巴西",list);
        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(1954);
        list1.add(1974);
        list1.add(1990);
        list1.add(2014);
        map.put("德国",list1);
        ArrayList<Integer> list2=new ArrayList<>();
        list2.add(1934);
        list2.add(1938);
        list2.add(1982);
        list2.add(2006);
        map.put("法国",list2);
        ArrayList<Integer> list3=new ArrayList<>();
        list3.add(1998);
        list3.add(2018);
        map.put("阿根廷",list3);
        ArrayList<Integer> list4= new ArrayList<>();
        list4.add(1978);
        list4.add(1986);
        map.put("乌拉圭",list4);
        ArrayList<Integer> list5=new ArrayList<>();
        list5.add(1996);
        map.put("英格兰",list5);
        ArrayList<Integer> list6=new ArrayList<>();
        list6.add(2010);
        map.put("西班牙",list6);
        System.out.println("请输入国家名获取夺冠信息：");
        String next = scanner.next();
        if (map.get(next)!=null){
            System.out.println("时间"+map.get(next)+"\t"+map.get(next).size()+"次");
        }else {
            System.out.println("没有获取世界杯记录");
        }
    }

遍历LinkedList

package com.la.demo05;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
public class TestQ {
    public static void main(String[] args) {
        String[] strs={"12345","67891","12347809933","98765432102","67891","12347809933"};
        List<String> list=new LinkedList<>();
        HashSet<String> integers = new HashSet<>();
        for (String str : strs) {
            integers.add(str);
        }
        list.addAll(integers);
        for (String s : list) {
            System.out.println(s);
        }
        System.out.println("-------------------------------------");
        ListIterator<String> listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
    }
}