2024年groovy基础语法学习，2024年最新美团面试软件

结语

由于篇幅限制，文档的详解资料太全面，细节内容太多，所以只把部分知识点截图出来粗略的介绍，每个小节点里面都有更细化的内容！以下是目录截图：

由于整个文档比较全面，内容比较多，篇幅不允许，下面以截图方式展示 。

再附一部分Android架构面试视频讲解：

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

3: [name: ‘huang3’, age: 19],

4: [name: ‘huang4’, age: 21],

5: [name: ‘huang4’, age: 18]

]

/**

• 遍历

*/

students.each { def student ->

println “key===>$student.key,value==>${student.value}”

}

/**

• 带索引的遍历

*/

students.eachWithIndex { def student, int position ->

println “index===>$position,key===>${student.key},value==>${student.value}”

}

/**

• 直接遍历key-value

*/

students.each { key, value ->

println “key==>$key,value==>${value}”

}

/**

• 带索引的直接遍历key-value

*/

students.eachWithIndex { key, value, position ->

println “index===>$position,key===>${key},value==>${value}”

}

/**

• map的查找

*/

def entry = students.find { def student ->

return student.value.age > 19

}

println entry//2={name=huang2, age=20}

def entrys = students.findAll { def student ->

return student.value.age > 19

}

println entrys//[2:[name:huang2, age:20], 4:[name:huang4, age:21]]

def count = students.count { def student ->

return student.value.age > 19

}

println count//2

def names = students.findAll { def student ->

return student.value.age > 19

}.collect {

return it.value.name//过滤名字

}

println names.toListString()//[huang2, huang4]

/**

• 分组

*/

def group = students.groupBy { def student ->

return student.value.age >= 18 ? ‘成年’ : ‘未成年’

}

println group.toMapString()//[未成年:[1:[name:huang1, age:17]], 成年:[2:[name:huang2, age:20], 3:[name:huang3, age:19], 4:[name:huang4, age:21], 5:[name:huang4, age:18]]]

/**

• 排序

*/

def sort = students.sort { def student1, def student2 ->

Number socre1 = student1.value.age

Number socre2 = student2.value.age

return socre1 == socre2 ? 0 : socre1 < socre2 ? -1 : 1

}

println sort.toMapString()//[1:[name:huang1, age:17], 5:[name:huang4, age:18], 3:[name:huang3, age:19], 2:[name:huang2, age:20], 4:[name:huang4, age:21]]

• 闭包

/**

• 闭包

*/

def clouser = { println “Hello groovy” }

clouser.call()

clouser()

/**

• 闭包传参

*/

def clouser1 = { String name, int age -> println “Hello ${name},age is ${age}” }

clouser1.call(“huang”, 18)

clouser1(“groovy”, 99)

/**

• 闭包传参(默认，隐式参数)

*/

def clouser2 = { println “Hello ${it}” }

clouser2.call(“huang”)

clouser2(“groovy”)

/**

• 返回值

*/

def clouser3 = { String name -> return “Hello ${name}” }

def result = clouser3(“huangxiaoguo”)

println result

println “------------------------------------------------闭包在基本数据类型中使用-----------------------------------------”

/**

• 用来求指定number的阶乘

• @param number

• @return

*/

int fab(int number) {

int result = 1

1.upto(number, { num -> result *= num })

return result

}

int fab2(int number) {

int result = 1

number.downto(1) {

//在groovy中可以把Closure放到括号外面，效果一样

num -> result *= num

}

return result

}

//int x = fab(5);

int x = fab2(5);

println x

/**

• 求和，（注意times的起始值一直是0，因此不能用作阶乘等其他操作）

• @param number

• @return

*/

int cal(int number) {

int result;

number.times {

num -> result += num

}

return result

}

int x1 = cal(101);

println x1

/**

• 绝对值

• @param number

• @return

*/

int abs(int number) {

return number.abs()

}

int x2 = abs(-101);

println x2

println “---------------------------------------------字符串和闭包结合使用-----------------------------------------------”

String str = “love and 2 to be 1 love all 8 happiness”

/**

• each的遍历

*/

str.each {

// String temp ->print temp.multiply(2)

String temp -> print temp

}

println()

/**

• find来查找符合条件的第一个

*/

println str.find {

String s -> s.isNumber()

} //2

/**

• findAll来查找符合条件的集合

*/

def list = str.findAll { String s -> s.isNumber() }

println list.toListString()//[2, 1, 8]

/**

• 只要满足就是true

*/

println str.any {

s -> s.isNumber()

}

/**

• 要全部满足才返回true

*/

println str.every {

s -> s.isNumber()

}

/**

• 遍历所有字母

*/

def list2 = str.collect {

it.toUpperCase()

}

println list2.toListString()//[L, O, V, E, , A, N, D, , 2, , T, O, , B, E, , 1, , L, O, V, E, , A, L, L, , 8, , H, A, P, P, I, N, E, S, S]

println “-------------------------------------闭包的三个重要变量：this,owner,delegate-----------------------------------”

def scriptClouser={

println “scriptClouser this:”+this//代表闭包定义处的类

println “scriptClouser owner:”+owner//代表闭包定义处的类或者对象

println “scriptClouser delegate:”+delegate//代表任意对象,默认与owner一致

}

scriptClouser.call()

/**

• 定义了一个内部类

*/

class Person{

def static classClouser={

println “scriptClouser this:”+this

println “scriptClouser owner:”+owner

println “scriptClouser delegate:”+delegate

}

def static say(){

def classClouser={

println “methodScriptClouser this:”+this

println “methodScriptClouser owner:”+owner

println “methodScriptClouser delegate:”+delegate

}

classClouser.call()

}

}

Person.classClouser.call()

Person.say()

println “-------------------------------------”

/**

• 闭包中定义一个闭包

*/

def nesrClouser={

def innerClouser={

println “innerClouser this:”+this

println “innerClouser owner:”+owner//与this不一样,variable.clouserstudy$_run_closure12@1500b2f3

println “innerClouser delegate:”+delegate //默认和owner一样

}

innerClouser.delegate=Person //修改默认的delegate, delegate:class variable.Person

innerClouser.call()

}

nesrClouser.call()

println “------------------------------------------------闭包的委托策略-------------------------------------------------”

class Student{

String name;

def pretty ={

“My name is ${name}”

}

String toString(){

pretty.call()

}

}

class Teacher{

String name

}

def stu = new Student(name:“Student”)

def tea = new Teacher(name: ‘Teacher’)

println stu.toString()//My name is Student

stu.pretty.delegate=tea

//修改委托策略（DELEGATE_FIRST,DELEGATE_ONLY…）

stu.pretty.resolveStrategy=Closure.DELEGATE_FIRST//有限寻找tea，找不到再找stu

println stu.toString()//My name is Teacher

• 面向对象

创建接口

/**

• 接口中不允许定义非public的方法

*/

interface Action {

void eat()

void drink()

void play()

}

创建抽象接口

/**

• 类似于interface ，但是trait可以进行方法的实现（类似java中的abstract）

*/

trait DefaultAction {

abstract void eat();

void play1(){

println ‘DefaultAction’

}

}

构建对象

/**

• 1.groovy中默认都是public类型

*/

class Persion implements Action, DefaultAction {

String name

Integer age

def increaseAge(Integer years) {

this.age = years

}

@Override

void eat() {

}

@Override

void drink() {

}

@Override

void play() {

}

/**

• 一个方法找不到时，调用它代替

• @param name

• @param args

• @return

*/

def invokeMethod(String name, Object args) {

return “name=>$name,args=>${args}”

}

def methodMissing(String name, Object args){

return “the method ${name} is missing”

}

}

具体操作

/**

• 2无论你是直接，还是调用get/set最终都是调用get/set

*/

def persion = new Persion(name: ‘android’, age: 26)

println " name is ${persion.name},age is ${persion.getAge()}"// name is android,age is 26

persion.increaseAge(20)

println " name is ${persion.name},age is ${persion.getAge()}"// name is android,age is 20

persion.play1() //DefaultAction

//the method cry is missing

println persion.cry()//没有cry这个方法时，默认调用methodMissing方法->没有的话->invokeMethod方法

/**

• 为类动态的添加一个属性

*/

Persion.metaClass.sex = ‘我是动态添加的属性’

Persion.metaClass.nameMethod = { -> name.toUpperCase() }

Persion.metaClass.static.createPerson={

String name, int age->new Persion(name: name,age: age)

}

def person = new Persion(name: ‘android’, age: 26)

println person.sex //我是动态添加的属性

person.sex = ‘修改属性’

println person.sex //修改属性

println person.nameMethod() //ANDROID

def person1 = Persion.createPerson(“dongtai”, 99)

println person1.name+“,”+person1.age //dongtai,99

• groovy 运行时时序表

• json操作

/**

• 1.groovy中默认都是public类型

*/

class Person implements Serializable {

String name

Integer age

String getName() {

return name

}

void setName(String name) {

this.name = name

}

Integer getAge() {

return age

}

void setAge(Integer age) {

this.age = age

}

}

import groovy.json.JsonOutput

import groovy.json.JsonSlurper

import objectorention.Persion

def list=[new Persion(name: ‘huangxiaoguo1’,age: 25),

new Persion(name: ‘huangxiaoguo2’,age: 26),

new Persion(name: ‘huangxiaoguo3’,age: 27),

new Persion(name: ‘huangxiaoguo4’,age: 28)]

/**

• 将对象转换为json

*/

println JsonOutput.toJson(list)

/**

• 打印格式化的json串

*/

def json = JsonOutput.toJson(list)

println JsonOutput.prettyPrint(json)

/**

• 将json串转换为实体对象

*/

def jsonSlpuer=new JsonSlurper()

def parse = jsonSlpuer.parseText(json)

println parse.toString()

println “--------------------------------groovy中进行网络请求---------------------------------------------”

def getNetworkData(String url){

//发送http请求

def connection=new URL(url).openConnection()

connection.setRequestMethod(‘GET’)

connection.connect()

def request = connection.content.text

//将json转换为实体对象

def jsonSlpuer=new JsonSlurper()

return jsonSlpuer.parseText(request)

}

def reponse = getNetworkData(“http://******/wsd/dictionary/getMapByDicflag?dicFlag=wsd.grade.type”)

println reponse.data

• xml操作

import groovy.xml.MarkupBuilder

final String xml=‘’’

/website/about/index.html

<![CDATA[

]]>

/website/categories/index.html

<![CDATA[]]>

/website/tags/index.html

<![CDATA[]]>

/website/tags2/index.html

<![CDATA[]]>

‘’’

println “------------------------------------------------解析xml-----------------------------------------”

/**

• 开始解析xml数据

*/

def xmlSlurper = new XmlSlurper()

def search = xmlSlurper.parseText(xml)

println search.entry[0].url.text();//打印内容，/website/about/index.html

println search.entry[0].content.@type;//打印属性，html

/**

• 遍历

*/

def list=[]

search.entry.each{ entry->

def title=entry.title.text();

if (title.equals(“标签”)){

list.add(entry.url.text())

}

}

println list.toListString() //[/website/tags/index.html, /website/tags2/index.html]

/**

• 深度遍历xml数据（即使xml多层也可以找到）

*/

def titles= search.depthFirst().findAll {entry->

return entry.title.text()==‘标签’?true:false

}

println titles.toListString() //[/website/tags/index.html标签, /website/tags2/index.html标签]

/**

• 广度遍历xml数据

*/

def urls= search.children().findAll {node->

node.title==‘标签’&&node.@id==‘3’

}.collect{node->

return node.url.text()

}

println urls //[/website/tags/index.html]

println “------------------------------------------------生成xml-----------------------------------------”

/**

16

10

Python

*/

def writer = new StringWriter()

def xmlBuilder = new MarkupBuilder(writer)//用来生成xml数据的核心类

//根节点langs创建

xmlBuilder.langs(type:‘curent’,count:‘3’,mainstream:‘true’){

//创建language结点

language(flavor:‘static’,version:‘1.5’,){

age(16)

}

language(flavor:‘dynamic’,version:‘1.6’,){

age(10)

}

language(flavor:‘dynamic’,version:‘1.7’,‘Python’)

}

println writer

/**

• 动态生成

*/

def writer1 = new StringWriter()

def xmlBuilder1 = new MarkupBuilder(writer1)//用来生成xml数据的核心类

def langs = new Langs();

xmlBuilder1.langs(type:langs.type,count: langs.count,mainstream: langs.mainstream ){

langs.langages.each{lang->

language(flavor:lang.flavor, version:lang.version, value:lang.value)

}

}

class Langs{

String type=‘curent’

int count=3

boolean mainstream=true

def langages=[

new Language(flavor:‘static’,version:‘1.5’,value:“java”),

new Language(flavor:‘dynamic’,version:‘1.6’,value: “H5”),

new Language(flavor:‘dynamic’,version:‘1.7’,value: “java”)

]

}

class Language{

String flavor

String version

String value

}

println writer1

• file操作

/**

• 文件操作

*/

def file = new File(‘…/…/groovy.iml’)

file.eachLine { line ->

println line

}

println “-----------------------------------------------------------------------------------------”

def text = file.getText()

println text

println “-----------------------------------------------------------------------------------------”

def lines = file.readLines()

println lines

println “-----------------------------------------------------------------------------------------”

/**

• 读取文件部分内容

*/

def reader = file.withReader { reader ->

char[] buffer = new char[100]

reader.read(buffer)

return buffer

}

println reader

println “-----------------------------------------------------------------------------------------”

学习福利

【Android 详细知识点思维脑图（技能树）】

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。

这里附上上述的面试题相关的几十套字节跳动，京东，小米，腾讯、头条、阿里、美团等公司19年的面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

由于篇幅有限，这里以图片的形式给大家展示一小部分。

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

ext

println “-----------------------------------------------------------------------------------------”

def lines = file.readLines()

println lines

println “-----------------------------------------------------------------------------------------”

/**

• 读取文件部分内容

*/

def reader = file.withReader { reader ->

char[] buffer = new char[100]

reader.read(buffer)

return buffer

}

println reader

println “-----------------------------------------------------------------------------------------”

学习福利

【Android 详细知识点思维脑图（技能树）】

[外链图片转存中…(img-SUnTg0r4-1715690649335)]

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。

这里附上上述的面试题相关的几十套字节跳动，京东，小米，腾讯、头条、阿里、美团等公司19年的面试题。把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节。

由于篇幅有限，这里以图片的形式给大家展示一小部分。

[外链图片转存中…(img-saYEl95l-1715690649335)]

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！