Java学习笔记-基础语法Ⅷ-泛型、Map
泛型
泛型本质上是参数化类型，也就是说所操作的数据类型被指定为一个参数，即将类型由原来的具体的类型参数化，然后在使用/调用时传入具体的类型，这种参数类型可以用在类、方法和接口中，分别为泛型类、泛型方法、泛型接口
// 泛型类
public class GenericDemo <T>{
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
// 测试类
public class Demo {
public static void main(String[] args) {
GenericDemo<String> gd1 = new GenericDemo<>();
gd1.setT("林青霞");
System.out.println(gd1.getT());
System.out.println("--------");
GenericDemo<Integer> gd2 = new GenericDemo<>();
gd2.setT(18);
System.out.println(gd2.getT());
}
}
在这里，测试类中创建泛型类对象时，最好指定数据类型
泛型方法：
public class GenericFunc {
public <T>void show(T t){
System.out.println(t);
}
}
public class Test {
public static void main(String[] args) {
GenericFunc gf = new GenericFunc();
gf.show("Hello");
}
}
泛型接口：
public interface Generic <T>{
void show(T t);
}
public class GenericImpl<T> implements Generic<T>{
@Override
public void show(T t) {
System.out.println(t);
}
}
public class Demo {
public static void main(String[] args) {
Generic<String> gc1 = new GenericImpl<>();
gc1.show("Hello");
Generic<Integer> gc2 = new GenericImpl<>();
gc2.show(100);
}
}
类型通配符
为了表示各种泛型List的父类，可以使用类型通配符
- 类型通配符：<?>
- List<?>表示元素类型未知的List，它的元素可以匹配任何的类型
- 这种带通配符的List仅表示它是各种泛型List的父类，并不能把元素添加到其中
import java.util.ArrayList;
import java.util.List;
public class MyGeneric {
public static void main(String[] args) {
List<?> list1 = new ArrayList<String>();
// 不能添加
// list1.add(12);
List<String> list2 = new ArrayList<>();
// 不能添加
list2.add("Hello");
System.out.println(list2);
}
}
public static <T> void test(List<T> c, T t){
// 可以添加
c.add(t);
}
那么类型通配符到底有什么用呢
import java.util.List;
public class MyGeneric {
public void test3(List<?> c){
for (int i = 0; i < c.size(); i++) {
System.out.println(c.get(i));
}
}
}
import java.util.ArrayList;
import java.util.List;
public class Demo {
public static void main(String[] args) {
MyGeneric mg = new MyGeneric();
List<String> ls1 = new ArrayList<>();
ls1.add("Hello");
ls1.add("World");
mg.test3(ls1);
System.out.println("-------");
List<Integer> ls2 = new ArrayList<>();
ls2.add(66);
ls2.add(666);
mg.test3(ls2);
}
}
想了下，在不知道类型参数情况下，可以用类型通配符，且还可以使用类型通配符上限，以及类型通配符下限
可变参数：
- python中用*，而java中用...
- 可变的参数和python一样都是数组
- 如果一个方法有多个参数，包含可变参数，可变参数要放在最后
Map集合
Map集合概述：
- Interface Map<K,V> k是键的类型，V是值的类型
- 将键映射到值的对象，不能包含重复的键，每个键可以映射到最多一个值
import java.util.HashMap;
import java.util.Map;
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
System.out.println(map.put("abc","123"));
// null
System.out.println(map);
}
}
Map的获取：
- 根据键获取：get方法，返回V
- 获得全部键：keySet方法，返回Set集合，因为键是不重复的
- 获得全部值：values方法，返回Collection，值是可重复的
- 获取键值对：entrySet方法
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
Map<String,String> map = new HashMap<>();
map.put("1","机器学习");
map.put("2","深度学期");
map.put("3","自然语言处理");
map.put("4","计算机视觉");
// 通过具体键获得值
String s = map.get("1");
System.out.println(s);
// 获得全部键，返回的是Set
Set<String> strings = map.keySet();
System.out.println(strings);
// 获得全部值，返回的是Collection
Collection<String> values = map.values();
System.out.println(values);
// 通过entrySet方法
Set<Map.Entry<String, String>> entries = map.entrySet();
for(Map.Entry<String, String> me:entries){
System.out.println(me.getKey()+" "+me.getValue());
}
}
}
机器学习
[1, 2, 3, 4]
[机器学习, 深度学期, 自然语言处理, 计算机视觉]
1 机器学习
2 深度学期
3 自然语言处理
4 计算机视觉
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;
public class Demo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
String[] strings = line.split("");
Map<String,Integer> map = new HashMap<>();
for(int i = 0;i<strings.length;i++){
String string = strings[i];
if(map.containsKey(string)){
Integer integer = map.get(string);
integer += 1;
map.put(string,integer);
}else{
map.put(string,1);
}
}
// 遍历
Set<String> strings1 = map.keySet();
for(String s:strings1){
Integer integer = map.get(s);
System.out.print(s+"("+integer+")");
}
}
}
之前学了个集合的工具类Arrays，现在学习另一个工具类Collections
有了这个工具类之后，连ArrayList也可以进行排序了(之前学习的是TreeSet)
// 学生类
public class Student {
private int age;
private String name;
public Student(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
// 测试类
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
public class Demo {
public static void main(String[] args) {
Student s1 = new Student(18,"张三");
Student s2 = new Student(19,"李四");
Student s3 = new Student(18,"王五");
ArrayList<Student> arr = new ArrayList<>();
arr.add(s1);
arr.add(s2);
arr.add(s3);
Collections.sort(arr, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
int num1 = o1.getAge()-o2.getAge();
int num2 = num1 == 0?o1.getName().compareTo(o2.getName()):num1;
return num2;
}
});
for(Student s:arr){
System.out.println(s.getAge()+" "+s.getName());
}
}
}
// 实现1
import java.util.ArrayList;
import java.util.Collections;
public class PokerDemo {
public static void main(String[] args) {
ArrayList<String> arr = new ArrayList<>();
String [] color = {"♦","♥","♣","♠"};
String [] point = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
for(int i = 0;i< color.length;i++){
for(int j = 0;j< point.length;j++){
String s = color[i] + point[j];
arr.add(s);
}
}
Collections.shuffle(arr);
ArrayList<String> p1 = new ArrayList<>();
ArrayList<String> p2 = new ArrayList<>();
ArrayList<String> p3 = new ArrayList<>();
ArrayList<String> p4 = new ArrayList<>();
for(int i = 0;i<arr.size();i++){
if(i> arr.size()-3){
p4.add(arr.get(i));
}else if(i%3==0){
p1.add(arr.get(i));
}else if(i%3==1){
p2.add(arr.get(i));
}else if(i%3==2){
p3.add(arr.get(i));
}
}
System.out.println(p1);
}
}
// 实现2
import java.util.*;
public class Poker {
public static void main(String[] args) {
// 用HashMap存储一副扑克牌
HashMap<Integer,String> poker = new HashMap<>();
String [] color = {"♦","♥","♣","♠"};
String [] point = {"2","3","4","5","6","7","8","9","10","J","Q","K","A"};
int index = 0;
ArrayList<Integer> arrIndex = new ArrayList<>();
for(int i = 0;i<color.length;i++){
for(int j =0;j< point.length;j++){
String s = color[i] + point[j];
poker.put(index,s);
arrIndex.add(index);
index++;
}
}
poker.put(index,"小王");
arrIndex.add(index);
index++;
poker.put(index,"大王");
arrIndex.add(index);
// 用ArrayList存储索引，等会打乱索引
// 打乱排序
Collections.shuffle(arrIndex);
// System.out.println(arrIndex);
// 为了让拿到的牌排好序，使用TreeSet集合
TreeSet<Integer> player1 = new TreeSet<>();
TreeSet<Integer> player2 = new TreeSet<>();
TreeSet<Integer> player3 = new TreeSet<>();
TreeSet<Integer> referee = new TreeSet<>();
// 给玩家发牌
for(int i = 0;i<arrIndex.size();i++){
Integer num = arrIndex.get(i);
if(i>=arrIndex.size()-3){
referee.add(num);
}else if(i%3 == 0){
player1.add(num);
}else if(i%3 == 1){
player2.add(num);
}else if(i%3 == 2){
player3.add(num);
}
}
// 看牌，封装成函数
showPoker("Player1",player1,poker);
showPoker("Player2",player2,poker);
showPoker("Player3",player3,poker);
showPoker("Referee",referee,poker);
}
// 传入进来玩家、扑克牌、Map
public static void showPoker(String name,TreeSet<Integer>ts,HashMap<Integer,String>map){
System.out.println(name+"的牌是：");
System.out.print("\t");
for(Integer i:ts){
String s = map.get(i);
System.out.print(s+", ");
}
System.out.println();
}
}
