用List来实现一个简单的Map(包含key, 和Value),这个简单Map需要提供（add, get, remove）的基本功能。

Posted 2023-04-24

我是初学者，大学学硬件，从没学过JAVA，公司要培训这个，帮帮忙吧，谢谢啦。

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

public class MyMap
//键(key)
private List<String> key;
//值(values)
private List<Object> value;
/**
* 构造方法
*/
public MyMap()
//初始化
key=new ArrayList<String>();
value=new ArrayList<Object>();

/**
* 增加
* @param k
* @param v
*/
public void add(String k,Object v)
key.add(k);
value.add(v);

/**
* 获取
* @param k
* @return
*/
public Object get(String k)
Object obj=null;
//遍历key,当与传入的值相同时，则取出对应位置的value
for(int i=0;i<key.size();i++)
if(key.get(i).equals(k))
obj=value.get(i);


return obj;

/**
* 删除
* @param k
*/
public void remove(String k)
//遍历key,当与传入的值相同时，则删除对应位置的key和value
for(int i=0;i<key.size();i++)
if(key.get(i).equals(k))
key.remove(i);
value.remove(i);



参考技术A import java.util.ArrayList;
import java.util.List;

public class MyMap

private List key;
private List value;

public MyMap()
key = new ArrayList();
value = new ArrayList();


public void add(Object k, Object v)
key.add(k);
value.add(v);


public void remove(Object k)
int i = getIndex(k);
if (i != -1)
key.remove(i);
value.remove(i);



public Object get(Object k)
int i = getIndex(k);
if (i != -1)
return value.get(i);

return null;


private int getIndex(Object k)
for (int i = 0; i < key.size(); i++)
if (key.get(i).toString().equals(k.toString()))
return i;


return -1;


public int size()
return key.size();


/**
* @param args
*/
public static void main(String[] args)
MyMap map = new MyMap();
map.add("1", 11);
map.add("2", 22);
map.add("3", 33);

System.out.println(map.get("2"));

map.remove("2");

System.out.println(map.get("2"));

Kotlin语法学习_Lambda编程

Lambda编程

集合的创建和遍历方式

• 集合只要包含List和Set在宽泛一些就包括Map这种键值对类型的数据结构
• List,Set和Map在java当中都是接口,其中List的主要实现类是ArrayList和LinkedList,Set的主要用的实现类是HashSet,Map主要用的实现类是HashMap
• 现在我们要创建一个水果集合来放水果,在Kotlin当中可以这样写

val list = ArrayList<String>()
list.add("苹果")
list.add("香蕉")
list.add("橘子")

• 这种初始化集合的方式比较繁琐,在Kotlin当中给我们提供了一个listOf方法可以简化集合的初始化

val list = listOf<String>("苹果", "香蕉", "橘子")

• 使用Kotlin当中的for-in方法对集合进行遍历

fun main() 
    val list = listOf<String>("苹果", "香蕉", "橘子")
    for (fruit in list) 
        println(fruit)
    

• 需要注意的是使用listOf方法初始化的集合是一种不可变的集合,意思就是使用listOf初始化的集合只能用来读取不能用来添加,修改或者删除
• 那么我们要是想要快速初始化一个集合,又想要可变可以使用mutableListOf方法进行初始化

fun main() 
    val list = mutableListOf<String>("苹果", "香蕉", "橘子")
    list.add("哈密瓜")
    for (fruit in list) 
        println(fruit)
    

• Set集合地用户几乎和List一样,只是将创建集合地方式换成了setOf和mutableSetOf

val set = setOf<String>("香蕉", "橘子", "苹果")

• set集合存放的元素是不可重复的
• Map集合的用法在Kotlin当中也比较多,和java比较类似的是下面这一种

 val map = HashMap<String, Int>()
 map.put("香蕉", 1)
 map.put("西瓜", 2)

• 但是在Kotlin当中还有一种类似于数组下标的写法

val map = HashMap<String, Int>()
map["香蕉"] = 1
map["西瓜"] = 2

• 而在map中读取一条写法

map.get("香蕉")
//或者还可以是这样(推荐)
map["香蕉"]

• 当然上面这些都不是最简单的写法,在Kotlin当中给Map也提供了mapOf和mutableMapOf两个函数进行快速的初始化

fun main() 
    val map = mapOf<String, Int>("香蕉" to 1, "西瓜" to 2)
    for ((fruit, number) in map) 
        println("fruit is " + fruit + "number is " + number)
    

集合的函数式API

• 在一个水果集合当中,找到单词最长那个水果

写法一:

 val list = listOf<String>("Apple", "Banana", "Orange", "Pear")
 var maxLengthFruit = ""
 for (fruit in list) 
     if (fruit.length > maxLengthFruit.length) 
         maxLengthFruit = fruit
     
 
 println("max length fruit is " + maxLengthFruit)

写法二:(使用函数式API写法)

    val list = listOf<String>("Apple", "Banana", "Orange", "Pear")
    val maxLengthFruit = list.maxBy  it.length 
    println("max length fruit is " + maxLengthFruit)

• 上面的代码不易理解,下面一步步分析Lambda表达式的写法
• Lambda定义:就是一小段可以作为参数传递的代码
• Lambda表达式的语法结构体

参数名1: 参数类型, 参数名2: 参数类型 -> 函数体

• 回到刚才找出最长单词的水果的需求,其中maxBy就是一个普通的函数而已,只不过就是接收了一个Lambda类型的参数,并且在遍历的时候将每次遍历的值传递给Lambda表达式,maxBy函数就是根据我们传入的条件来遍历集合,从而找到该条件下的最大值
• 理解原理之后这个代码就可以这样写了

    val list = listOf<String>("Apple", "Banana", "Orange", "Pear")
    //定义一个lambda表达式
    val lambda = fruit: String -> fruit.length
    //然后将这个lambda表达式作为参数传递给maxBy函数,maxBy函数的作用就是遍历集合,根据参数条件来找到最大值
    val maxLengthFruit = list.maxBy(lambda)

• 但是上述写法比较啰嗦麻烦,可以在此基础上进行简化操作
• 首先不需要专门定义一个Lambda变量,而是可以直接将Lambda表达式传入maxBy函数中

val maxLengthFruit = list.maxBy(fruit: String -> fruit.length)

• 然后在Kotlin当中规定当Lambda表达式是函数最后一个参数的时候,可以将Lambda表达式一道函数括号外面

val maxLengthFruit = list.maxBy()fruit: String -> fruit.length

• 如果当lambda参数是函数唯一一个参数的时候,函数的括号可以省略

val maxLengthFruit = list.maxByfruit: String -> fruit.length

• 然后在Kotlin当中拥有优秀的推到机制,Lambda表达式中的参数列表在大多数的情况下没必要声明参数的类型,因此可以进一步简化成为

val maxLengthFruit = list.maxByfruit -> fruit.length

• 最后在Lambda中当参数列表只有一个参数的时候,也不必要声明参数名,而是直接使用it关键字代替即可,那么代码就变成了

val maxLenght = list.maxByit.length

• 集合当中的map函数是比较常用的一种函数式API,它将用于集合中每个元素都映射成为一个另外的值,映射的规则在Lambda表达式中进行指定
• 将单词都转换成为大写字母

    val list = listOf<String>("Apple", "Banana")
    val newList = list.map  it.toUpperCase() 
    for (fruit in newList) 
        println(fruit)
    

• map函数的功能十分的强大,可以按照我们的需求对集合中的元素进行任意的映射转换
• filter函数:是用来过滤集合当中数据的,可以单独使用,也可以和map函数配合在一起进行使用
• 比如我们想保留5个字母以内的水果,并且将字母全部转换成为大写字母

val list = listOf<String>("Apple", "Banana", "Orange", "Pear", "Grape")
val newList = list.filter  it.length <= 5 
    .map  it.toUpperCase() 
for (fruit in newList) 
    println(fruit)

• any函数和all函数
• any函数用于判断集合中是否至少存在一个元素满足指定条件,all函数用于判断集合中是否所有元素都满足指定的条件

val list = listOf<String>("Apple", "Banana", "Orange", "Pear", "Grape")
val anyResult = list.any it.length <= 5
val allResult = list.all  it.length <= 5 
println("anyResult is" + anyResult + ", allResult is" + allResult)